Kotlin and why you should love it #2

Slides of the talk we gave in Ennova

1. KOTLIN AND WHY YOU SHOULD LOVE IT Part 2
2. LAMBDAS WITH RECEIVERS The ability to call methods of a different object in the body of a lambda without any additional qualifiers — Kotlin in Action
3. with fun alphabet(): String { val result = StringBuilder() for (letter in 'A'..'Z') { result.append(letter) } result.append("\nNow I know the alphabet!") return result.toString() }
4. with fun alphabet(): String { val stringBuilder = StringBuilder() return with(stringBuilder) { for (letter in 'A'..'Z') { this.append(letter) } append("\nNow I know the alphabet!") this.toString() } }
5. with fun alphabet() = with(StringBuilder()) { for (letter in 'A'..'Z') { append(letter) } append("\nNow I know the alphabet!") toString() }
6. apply fun alphabet() = StringBuilder().apply { for (letter in 'A'..'Z') { append(letter) } append("\nNow I know the alphabet!") }.toString()
7. with VS apply Declaration Return type with Function value of the lambda apply Extension method this
8. with VS apply inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block() inline fun <T> T.apply(block: T.() -> Unit): T { block() return this }
9. let VS run inline fun <T, R> T.run(block: T.() -> R): R = block() inline fun <T, R> T.let(block: (T) -> R): R = block(this)
10. DESTRUCTURING DECLARATION val mickey = Person("Mickey", "Mouse") val (name, lastName) = mickey
11. DESTRUCTURING DECLARATION val mickey = Person("Mickey", "Mouse") val (name, lastName) = mickey MEANS val name = mickey.component1() val lastName = mickey.component2()
12. LOCAL FUNCTIONS Functions can be nested inside a containing function And they have access to all parameters and variables of the enclosing function
13. LOCAL FUNCTIONS fun containing(a : Int) { fun nested() { return a + 2 } val b = nested() }
14. SEALED CLASSES sealed class Expr data class Const(val number: Double) : Expr() data class Sum(val e1: Expr, val e2: Expr) : Expr() object NotANumber : Expr()
15. SEALED CLASSES fun eval(expr: Expr): Double = when(expr) { is Const -> expr.number is Sum -> eval(expr.e1) + eval(expr.e2) NotANumber -> Double.NaN }
16. SINGLETON AKA object DECLARATIONS
17. object DataProviderManager { fun register(provider: Provider) { // ... } }
18. THIS IS NOT THE ONLY USE OF object
19. object EXPRESSIONS textView.addTextChangedListener(object : TextWatcher{ override fun afterTextChanged(...) {} override fun beforeTextChanged(...) {} override fun onTextChanged(...) {} })
20. COMPANION object class MyClass { companion object Factory { fun create(): MyClass = MyClass() } } val instance = MyClass.create()
21. COMPANION object class MyClass { companion object { } } val x = MyClass.Companion
22. object init > object declarations are initialized lazily, when accessed for the first time > object expressions are executed (and initialized) immediately, where they are used > a companion object is initialized when the corresponding class is loaded (resolved), matching the semantics of a Java static initializer
23. DELEGATION
24. interface Base { fun print() } class BaseImpl(val x: Int) : Base { override fun print() { print(x) } }
25. val b = BaseImpl(10)
26. class Derived(b: Base) : Base by b
27. val b = BaseImpl(10) Derived(b).print() This prints 10
28. class Derived(b: Base) : Base by b { override fun print() { print("abc") } }
29. val b = BaseImpl(10) Derived(b).print() This prints abc
30. STANDARD DELEGATES
31. lazy - THIS... val lazyValue: String by lazy { println("computed!") "Hello" } println(lazyValue) println(lazyValue)
32. lazy - ... WILL PRINT computed! Hello Hello
33. Delegates.observable() - THIS ... class User { var name: String by Delegates.observable("<no name>") { prop, old, new -> println("$old -> $new") } } fun main(args: Array<String>) { val user = User() user.name = "first" user.name = "second" }
34. Delegates.observable() - ... WILL PRINT <no name> -> first first -> second
35. THE HANDLER WILL BE CALLED AFTER THE VALUE HAS BEEN SET
36. Delegates.vetoable()
37. map DELEGATE class User(map: Map<String, Any?>) { val name: String by map val age: Int by map } val user = User(mapOf( "name" to "John Doe", "age" to 25 ))
38. COLLECTIONS: MUTABLE VS IMMUTABLE val list = listOf(1, 2, 3) //immutable list of ints val list = mutableListOf(1, 2, 3) //mutable list of ints
39. COLLECTIONS: MUTABLE VS IMMUTABLE > Mutable: you can insert, update and remove > Default: you can only query (contains, get, indexOf...) > MutableList / List > MutableSet / Set > MutableMap / Map
40. COLLECTIONS: IMMUTABILITY val list = listOf(1, 2, 3) val doubles = list.map { it * 2 } val pairs = list.filter { it % 2 == 0 } > doubles is a completely new list > The original list is never touched
41. COLLECTIONS: OPERATIONS > filter > map > any, none, all > firstOrNull
42. More info at https://kotlinlang.org/docs/reference/ delegated-properties.html
43. SLIDES bit.ly/ennova
44. THANKS!