Kotlin: Higher Order Functions

Selamlar!
Bu yazımda higher order functions konusunu inceleyeceğiz. Higher order functionsa geçmeden önce lambda expressions ve anonymous functions başlıklarını irdeleyelim. O zaman başlayalım!

Lambda Expressions

Lambda expressionlar ve anonymous functionlar function literals olarak adlandırılırlar. Yani deklare edilmeden anlık olarak kullanabilen bir yapıya sahiptirler.

• Lambda expression süslü parantezle başlar ve süslü parantezle biter.
• İlk süslü parantezden sonra parametreler ve tipleri yazılır. Parametreler birbirinden virgül ile ayrılır.
• Parametrelerden sonra “->” işareti konulur ve sonrasında fonksiyon body’si yazılır.
• Eğer dönüş tipi Unit değilse fonksiyon body’sinin son satırı dönüş değeri olarak alınır.

val sumWithLambda = { a: Int, b: Int ->
        a + b
    }

Eğer bir fonksiyonun son parametresi bir fonksiyon ise bu fonksiyonun son parametresini parantezlerin dışına alıp bir lambda expression olarak verebiliriz.

//    public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
//        for (element in this) action(element)
//    }

    val addTen = items.forEach { number: Int ->
        number+ 10
    }

it Kullanımı

Eğer lambda expressionunuz tek parametre bekliyorsa parametre adını ve “->” işaretini kullanmayabilirsiniz. Bu tip bir kullanımda süslü parantezlerin içinde parametrenize it yazarak ulaşabilirsiniz.

val addTen = items.forEach { it + 10 }

Kullanılmayan lambda parametresinin ismi alt çizgi( _ ) ile değiştirilebilir.

val addTen = { a: Int, _: Int ->
        a + 10
    }

Anonymous Functions

Lambda expression kullandığımızda geri dönüş tipini açık açık yazamıyoruz. Böyle bir ihtiyacımız olduğunda anonymous function kullanabiliriz. Anonymous functionların normal fonksiyonlardan farkı isimsiz olmalarıdır.

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

Fonksiyonların Referans Gösterimi

Kotlin fonksiyonların tip olarak verilmesine olanak sağlar. Bu tip kullanıma fonksiyonların referans gösterimi deriz.

val sumFunction: (Int, Int) -> Int = { 
        number1:Int, number2:Int -> number1+number2 
    }

Referans gösterim right-associative çalışır. Yani sağ taraftan çağırılarak ilerler. (Int) -> (Int) -> Int şeklinde bir kullanım, (Int) -> ((Int) -> Int) şeklinde bir kullanım ile aynıdır. Fakat ((Int) -> (Int)) -> Int bunlardan farklı bir işleme tabi tutulur.

Higher Order Functions

Sıra geldi günün yıldızına. Parametre olarak fonksiyon alan veya fonksiyon döndüren fonksiyonlara higher order function diyoruz.

val sum: (Int, Int) -> Int = { num1, num2 -> num1 + num2 }

fun higherOrder(number1: Int, number2: Int, operation: (Int, Int) -> Int): Int =
        operation(number1, number2)

println(higherOrder(3, 4, sum))

Fonksiyon referansını “::” işareti ile de oluşturabiliriz. Varsa fonksiyonun beklediği parametreleri “::” işaretinden önce, işaretten sonra ise fonksiyonun adını yazarak referansını oluşturabiliriz. Bu konuda daha detaylı bilgiyi ileride reflection konusunda göreceğiz.

fun sum(num1:Int, num2:Int): Int = num1 + num2

fun applyOperation(number1: Int, number2: Int, operation: (Int, Int) -> Int): Int =
        operation(number1, number2)

println(applyOperation(3, 4, ::sum))

Okuduğun için teşekkür ederim. Yeni bir yazıda görüşmek üzere!

Kaynaklar:
- Halil Özcan
- kotlinlang.org
- Antonio Leiva