Idiomatic Kotlin

# Idiomatic Kotlin
### Andrey Akinshin, JetBrains

---

---

# Idiomatic

> Idiomatic — using, containing, or denoting expressions that are natural to a native speaker.
> 
> — Oxford Dictionary

---

### Agenda

---
class: middle
background-image: url(kotlin.png)

# Expressions

---

### Expression body

---

### when as an expression

.column-left[
```kotlin
fun parse(number: String): `Int?` {
    when (number) {
        "one" -> `return` 1
        "two" -> `return` 2
        else  -> `return` null
    }
}
```
]

.column-right[
```kotlin
fun parse(number: String) `=`
    when (number) {
        "one" -> 1
        "two" -> 2
        else  -> null
    }
```
]

---

### when and sealed classes

class Success
    : Result()
class Failure(val message: String)
    : Result()

fun handleResult(result: Result) =
  when (result) {
    is Success ->
      "OK!"
    is Failure ->
      "Failed: ${result.message}"
    `else ->`
      `throw IllegalArgumentException()`
  }
```
]

class Success
      : Result()
  class Failure(val message: String)
      : Result()

fun handleResult(result: Result) =
    when (result) {
      is Success ->
        "OK!"
      is Failure ->
        "Failed: ${result.message}"
    }
```
]

---

### try as an expression

.column-left[
```kotlin
fun tryParseInt(number: String): `Int?` {
  try {
    `return` Integer.parseInt(number)
  } catch (e: NumberFormatException) {
    `return` null
  }
}
```
]

.column-right[
```kotlin
fun tryParseInt(number: String) `=`
  try {
    Integer.parseInt(number)
  } catch (e: NumberFormatException) {
    null
  }
```
]

---

### Elvis

.column-left[
```kotlin
fun foo(name: String?) {
  val s = `if (name != null)`
    name
  `else`
    "?"
}
```
]

---

### Elvis before return

fun processPerson(p: Person) {
  val age = p.age
  `if (age == null)` return
  // ...
}
```
]

fun processPerson(p: Person) {
  val age `: Int` = p.age `?:` return
  // ...
}
```
]

---

### Elvis before throw

fun processPerson(p: Person) {
  val name = p.name
  `if (name == null)`
    throw IllegalArgumentException(
      "Name required")
  // ...
}
```
]

fun processPerson(p: Person) {
  val name = p.name `?:`
    throw IllegalArgumentException(
      "Name required")
  // ...
}
```
]

---

# Loops

---

### Ranges

---

### until in loops

.column-left[
```kotlin
fun main(args: Array<String>) {
  for (i in 0`..`args.size-1) {
    println("$i: ${args[i]}")
  }
}
```
]

.column-right[
```kotlin
fun main(args: Array<String>) {
  for (i in 0 `until` args.size) {
    println("$i: ${args[i]}")
  }
}
```
]

.footer[
```kotlin
public `infix` fun Int.until(to: Int): IntRange {
  if (to <= Int.MIN_VALUE) return IntRange.EMPTY
  return this .. (to - 1).toInt()
}
```
]

---

### withIndex in loops

.column-left[
```kotlin
fun main(args: Array<String>) {
  for (i in 0 `until` args.size) {
    println("$i: ${args[i]}")
  }
}
```
]

.column-right[
```kotlin
fun main(args: Array<String>) {
  for ((i, arg) in args`.withIndex()`) {
    println("$i: $arg")
  }
}
```
]

---

### deconstructors in loops

.column-left[
```kotlin
fun printMap(map: Map<String, String>) {
  for (item in map.entries) {
    println("${item.key}=${item.value}")
  }
}
```
]

.column-right[
```kotlin
fun printMap(map: Map<String, String>) {
  for (`(key, value)` in map) {
    println("`$key`=`$value`")
  }
}
```
]

---
class: middle
background-image: url(kotlin.png)

# Functions

---

### Top level functions

.column-left[
```kotlin
class `StringUtils` {
  `companion object` {
     fun containsZeros(s: String) =
        s.contains('0')
  }
}
```
]

---

### Extension functions

// Usage
val x = containsZeros("0123")
```
]

// Usage
val x = "0123"`.`containsZeros()
```
]

---
### Lambda expressions

.column-left[
```kotlin
fun evenCount(list: List<Int>) =
  list.count`(`{ `x ->` x % 2 == 0 }`)`
```
]

---

### Safe let call

fun printAddress(person: Person) {
  if (`person.address != null`) {
    println(person.address)
  }
}
```
]

fun printAddress(person: Person) {
  person.address`?.let` {
    println(it)
  }
}
```
]

.footer[
```kotlin
public `inline` fun <T, R> T.let(block: (T) -> R): R {
  return block(this)
}
```
]

---

### Initialization via apply

fun createLabel(): Label {
  val label = Label()
  `label.`text = "Click here"
  `label.`tooltip = "Help"
  return label
}
```
]

fun createLabel() =
  Label()`.apply` {
    text = "Click here"
    tooltip = "Help"
  }
```
]

.footer[
```kotlin
public `inline` fun <T> T.apply(block: `T.()` -> Unit): T {
  block()
  return this
}
```
]

---

### Overloads

fun print(separator: String) {
  }
}

fun main(args: Array<String>) {
  Phonebook().print("|")
}
```
]

fun main(args: Array<String>) {
  Phonebook().print(`separator =` "|")
}
```
]

---

### Return multiple values

fun namedNum(): `Pair<Int, String>` =
  1 to "one"

fun main(args: Array<String>) {
  val pair = namedNum()
  val number = pair`.first`
  val name = pair`.second`
}
```
]

fun namedNum() = NamedNumber(1, "one")

fun main(args: Array<String>) {
    val `(number, name)` = namedNum()
  }
```
]

---

### Multideclarations and lists

fun getInfo(fileName: String): FileInfo {
  if ('.' in fileName) {
    val `parts` : List<String> =
      fileName.split('.', limit = 2)
    return FileInfo(`parts[0], parts[1]`)
  }
  return FileInfo(fileName, null)
}
```
]

fun getInfo(fileName: String): FileInfo {
  if ('.' in fileName) {
    val `(name, ext)` =
      fileName.split('.', limit = 2)
    return FileInfo(`name, ext`)
  }
  return FileInfo(fileName, null)
}
```
]

---

### lateinit

var state: State? = null

@Before
  fun setup() {
    state = State("abc")
  }

@Test
  fun foo() {
    Assert.assertEquals(
        "abc",
        `state!!`.data
    )
  }
}
```
]

`lateinit` var state: State

@Before
  fun setup() {
      state = State("abc")
  }

@Test
  fun foo() {
      Assert.assertEquals(
          "abc",
          `state`.data
      )
  }
}
```
]
---

# StdLib

---

### require

.column-left[
```kotlin
fun calculate(n: Int) {
  if (n <= 0)
    throw IllegalArgumentException(
      "n should be positive")
  // ...
}
```
]

.column-right[
```kotlin
fun calculate(n: Int) {
  `require`(n > 0) {
    "n should be positive"
  }
  // ...
}
```
]

---

### filterIsInstance

val x: List<Any> = getStrings(objs)
```
]

val x: List<Strings> = getStrings(objs)
```
]

---

### mapNotNull

fun listErrors(results: List<Result>)
    : List<String> =
  results
    `.map` { it.error }
    `.filterNotNull()`
```
]

fun listErrors(results: List<Result>)
    : List<String> =
  results`.mapNotNull` { it.error }
```
]

---

### compareBy

fun sortPersons(persons: List<Person>) =
  persons.sortedWith(
    Comparator<Person> { p1, p2 ->
      val rc = p1.name
                 .compareTo(p2.name)
      if (rc != 0)
        rc
      else
        p1.age - p2.age
    })
```
]

fun sortPersons(persons: List<Person>) =
    persons.sortedWith(
      `compareBy`(Person::name,
                Person::age))
```
]

---

### groupBy

.column-left[
```kotlin
class Request(
  val url: String,
  val remoteIP: String,
  val timestamp: Long
)

fun analyzeLog(log: List<Request>) {
  val map = mutableMapOf<
    String, MutableList<Request>>()
  for (request in log) {
      map.getOrPut(request.url) {
        mutableListOf()
      }.add(request)
  }
}
```
]

.column-right[
```kotlin
class Request(
  val url: String,
  val remoteIP: String,
  val timestamp: Long
)

fun analyzeLog(log: List<Request>) {
  val map = log`.groupBy`(Request::url)
}
```
]

---

### coerceIn

.column-left[
```kotlin
fun updateProgress(value: Int) {
  val actualValue = when {
    value < 0   -> 0
    value > 100 -> 100
    else        -> value
  }
}
```
]

fun updateProgress(value: Int) {
  val actualValue =
    value`.coerceIn`(0, 100)
}
```
]

---

### zip

.column-left[
```kotlin
fun calcDurations(start: LongArray,
                  finish: LongArray) =
    start`.mapIndexed` { index, s ->
        finish[index] - s
    }
```
]

.column-right[
```kotlin
fun calcDurations(start: LongArray,
                  finish: LongArray) =
    (start `zip` finish).map {
      `(s, f) -> f - s`
    }

```
]

---
class: middle
background-image: url(kotlin.png)

# References

---
class: center

### Kotling Reference

https://kotlinlang.org/docs/reference/

---
class: center

### Kotlin in action

https://www.manning.com/books/kotlin-in-action

---
class: center

### Ideomatic Kotlin Repo

https://github.com/yole/idiomatic-kotlin/

---
background-image: url(kotlin.png)

# Questions?

Andrey Akinshin

https://aakinshin.net

https://github.com/AndreyAkinshin

https://twitter.com/andrey_akinshin

andrey.akinshin@gmail.com