Why Kotlin?

• Concise

  Drastically reduce the amount of boilerplate code

  /*

   Create a POJO with getters, setters, `equals()`, `hashCode()`, `toString()` and `copy()` in a single line:

  */

  data class Customer(val name: String, val email: String, val company: String)

  // Or filter a list using a lambda expression:

  val positiveNumbers = list.filter { it > 0 }

  // Want a singleton? Create an object:

  object ThisIsASingleton {

      val companyName: String = "JetBrains"

  }

• Safe

  Avoid entire classes of errors such as null pointer exceptions

  /*

   Get rid of those pesky NullPointerExceptions, you know, The Billion Dollar Mistake

  */

  var output: String

  output = null   // Compilation error

  // Kotlin protects you from mistakenly operating on nullable types

  val name: String? = null    // Nullable type

  println(name.length())      // Compilation error

  // And if you check a type is right, the compiler will auto-cast it for you

  fun calculateTotal(obj: Any) {

      if (obj is Invoice)

          obj.calculateTotal()

  }

• Interoperable

  Leverage existing libraries for the JVM, Android, and the browser

  /*

   Use any existing library on the JVM, as there’s 100% compatibility, including SAM support.

  */

  import io.reactivex.Flowable

  import io.reactivex.schedulers.Schedulers

  Flowable

      .fromCallable {

          Thread.sleep(1000) //  imitate expensive computation

          "Done"

      }

      .subscribeOn(Schedulers.io())

      .observeOn(Schedulers.single())

      .subscribe(::println, Throwable::printStackTrace)

  // Target either the JVM or JavaScript. Write code in Kotlin and decide where you want to deploy to

  import kotlin.browser.window

  fun onLoad() {

      window.document.body!!.innerHTML += "<br/>Hello, Kotlin!"

  }

• Tool-friendly

  Choose any Java IDE or build from the command line

---

Higher-Order Functions

A higher-order function is a function that takes another function as parameter and/or returns a function.

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {  // 1

    return operation(x, y)                                          // 2

}

fun sum(x: Int, y: Int) = x + y                                     // 3

fun main() {

    val sumResult = calculate(4, 5, ::sum)                          // 4

    val mulResult = calculate(4, 5) { a, b -> a * b }               // 5

    println("sumResult $sumResult, mulResult $mulResult")

}

Output：

sumResult 9, mulResult 20

1. Declares a higher-order function. It takes two integer parameters, x and y. Additionally, it takes another function operation as a parameter. The operation parameters and return type are also defined in the declaration.

2. The higher order function returns the result of operation invocation with the supplied arguments.

3. Declares a function that matches the operationsignature.

4. Invokes the higher-order function passing in two integer values and the function argument ::sum. :: is the notation that references a function by name in Kotlin.

5. Invokes the higher-order function passing in a lambda as a function argument. Looks clearer, doesn't it?