Lambda Expression & Anonymous Function & Higher Order Function Part-1

Selamlar, arkadaşlar! Bugün Lambda Expression ve Anonymous Fonksiyonlardan bahsedeceğim. İyi okumalar! :)

Lambda expression genel tanımlanması aşağıdaki gösterim gibidir.

()->Unit

Lambda expression kullanırken parametreler ve dönüş değeri verebiliriz.

val func = (Int,Float)-> Double

Burada 1. parametre Integer, 2. parametre Float ve dönüş değeri Double olarak belirtilmiştir.

Lambda expression’lar her zaman süslü parantezle çevrilir. “ {}”

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

Veya, isimlendirmelerin tipleri de belirterek de kullanılabilir.

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

Lambda expression’larda süslü parantezler içerisinde birden fazla işlem yapılabilir, fakat en son satırda dönüş değeri verilmelidir.

val sum: (Int, Int) -> Int = { number1: Int, number2: Int ->
        println("do sum")
        /*
        * another operation
        * */
        number1 + number2
    }

Lambda expression’ların son satırdaki ifadesi return olarak kabul edilir. return dememize gerek yoktur. Aynı zamanda lambda expression’lar type inference’dır.

Lambda expression’ları kullanmak için çağırmak istediğimizde normal fonksiyon gibi çağrılır.

//Type-1
sum(3, 4)

//Type-2
val result = sum(3, 4)
println(result)

Dikkat edilmesi gereken Type-1 kullanımında lambda expression çalıştırılır fakat çıktı olarak sadece “do sum” görülür. Toplama işleminin sonucunu görmek için lambda expression’ı bir değişkene eşitleyip değişkeni yazdırmamız gerekir.

Aynı zamanda lambda expression’ı kullanmak istediğimizde invoke() ile de kullanabiliriz.

sum(3,4)
//or
sum.invoke(3,4)

Ekstra olarak invoke olmasının sebebi lambda expression’ın nullable olabilmesidir.

val sum: ((Int, Int) -> Int)? = { number1: Int, number2: Int ->
        println("do sum")
        /*
        * another operation
        * */
        number1 + number2
    }

sadece fonksiyon ismi kullanarak çağırma yaptığımızda lambda expression nullable olduğu durumda “?” kullanamıyoruz

  sum(3,4) // hatalı kullanım
  sum?.invoke(3,4)  //kullanılabilir
    
  sum!!(3,4) //kullanılabilir
  sum!!.invoke(3,4) //kullanılabilir

Lambda expression tek parametre aldığı zaman otomatik olarak “it” diye isimlendirilir. “it” implicit (kapalı) olarak kendi içerisinde isimlendirmesi böyle yapılır.

it

Lambda expression’lar bir fonksiyonun son parametresi olarak tanımlandıysa fonksiyon parantezinden sonra süslü parantez ile ayrılabilir. Buna trailing lambda denir.

Lambda expressionlar fonksiyonların dışında süslü parantez ile kullanılabildiğinden sıralı sekilde LINGQ-style seklinde kullanılabilir.

val names = listOf("umutcan", "sahin")
names.filter {
    it.length > 5
}.sortedBy { 
    it.length
}.map { 
    it.uppercase()
}

Kullanılmayacak parametreler “_” seklinde gösterilir.

val anotherSum: (number1: Int, number2: Int) -> Int = { _, number2 ->
    number2 * number2
}

Lambda expression’lar return type’ı explicit(açık) olarak belirtemezler.

Anonymous Functions

Lambda expression’lar return type’ı explicit(açık) olarak belirtemedikleri için burada devreye Anonymous Fonksiyonlar girer.

Anonymous fonksiyonlar normal fonksiyon gibidir tek farkı isim almazlar.

val sum = fun(number1: Int, number2: Int): Int {
    return number1 + number2
}

Single expression olarak da kullanılabilirler.

val sum = fun(number1: Int, number2: Int): Int = number1 + number2
//or
val sum = fun(number1: Int, number2: Int) = number1 + number2