Devoxx France 2024. Kotlin - the new and noteworthy

Transcript

1. Kotlin - the new and notewor t hy @antonarhipov Devoxx France 2025
2. July 20, 2011 - Kotlin announced at JVMLS February 15, 2016 - Kotlin 1.0 May 21, 2024 - Kotlin 2.0
3. July 20, 2011 - Kotlin announced at JVMLS February 15, 2016 - Kotlin 1.0 May 21, 2024 - Kotlin 2.0 "A general purpose, statically typed, object-oriented alternative JVM programming language with type inference"
4. What are your favourite Kotlin features?
5. What are your favourite Kotlin features? Null-safety
6. What are your favourite Kotlin features? Null-safety Coroutines
7. What are your favourite Kotlin features? Null-safety Coroutines Multiplatform
8. What are your favourite Kotlin features? Null-safety Coroutines Multiplatform Syntax
9. What are your favourite Kotlin features? my
10. public class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public boolean equals(Object o) { if (this = = o) return true; if (o == null | | getClass() ! = o.getClass()) return false; Person person = (Person) o; if (age != person.age) return false; return name != null ? name.equals(person.name) : person.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } data class Person( val name: String, val age: Int ) It used to be very easy to create the wow effect with this:
11. data class Person( val name: String, val age: Int ) But now Java has records . public record Person( String name, int age ) {}
12. Kotlin still has a lot to offer:
13. fun main() { val event = "Devoxx" println("Hello, $event!") } Very simple to star t !
14. fun main() { val event = "Devoxx" println("Hello, $event!") } String templates
15. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") } String templates with expressions
16. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase()}!") } fun String.randomCase(chance: Double = 0.5): String { return map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Top-level functions
17. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase()}!") } fun String.randomCase(chance: Double = 0.5): String { return map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Extension functions!
18. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase()}!") } fun String.randomCase(chance: Double = 0.5): String = map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Single-expression functions!!
19. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase()}!") } fun String.randomCase(chance: Double = 0.5) = map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Type inference!!!
20. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase()}!") } fun String.randomCase(chance: Double = 0.5) = map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Default argument values
21. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase(offset = 0.25)}!") } fun String.randomCase(chance: Double = 0.5, offset: Double = 0.1) = map { if (Math.random() < chance) it.uppercaseChar() else it.lowercaseChar() }.joinToString("") } Named parameters
22. fun main() { val event = "Devoxx" println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase(offset = 0.25)}!") println("Hello, ${event.transform { it.randomCase(offset = 0.25) }} !") } fun String.transform(transformer: (String) -> String) = transformer(this) Trailing lambda as a parameter
23. fun main() { val event: String? = getEventName() println("Hello, ${event.uppercase()}!") println("Hello, ${event.randomCase(offset = 0.25)}!") } private fun getEventName(): String? = "Devoxx" Nullable types
24. fun main() { val event: String? = getEventName() println("Hello, ${event ? . uppercase()}!") println("Hello, ${event ! ! .randomCase(offset = 0.25)}!") } private fun getEventName(): String? = "Devoxx" Operators for working with null values
25. "Type-safe builders" a.k.a DSLs val client = createClient { firstName = "Anton" lastName = "Arhipov" twitter { handle = "@antonarhipov" } company { name = "JetBrains" city = "Tallinn" } dob = 24 March 2000 } println("Created client is: ${client.toS}")
26. Kotlin still has a lot to offer: These features combined make a huge difference in how we reason about the code and structure Kotlin programs
27. Features added after Kotlin 1.0 : - Multiplatform projects - Coroutines - Inline / Value classes - Trailing comma - fun inter f aces - .
28. Features added after Kotlin 1.0 : - Multiplatform projects - Coroutines - Inline / Value classes - Trailing comma - fun inter f aces - Type aliases - Sealed classes & inter f aces - Contracts - break/continue inside when - Exhaustive when statements - Builder inference - . . < operator - Data objects
29. Features added after Kotlin 1.0 : - Multiplatform projects - Coroutines - Inline / Value classes - Trailing comma - fun inter f aces - Type aliases - Sealed classes & inter f aces - Contracts - break/continue inside when - Exhaustive when statements - Builder inference - ..< operator - Data objects - provideDelegate - Bound callable references - Destructuring in lambdas - Array literals in annotations - Local lateinit variables - Opt-in annotations - Definitely non-nullable types - Instantiation of annotation classes - Suppor t for JSpecify - suspend functions as super t ypes - Secondary constructors for inline value classes A LOT
31. Technical debt strikes back
32. K2 Fighting technical debt
33. K2 : The new Kotlin compiler - why?
34. K2 : The new Kotlin compiler - why? "K1 was a prototype" - someone
35. K2 : The new Kotlin compiler - why? 1. A few language features have appeared unexpectedly in Kotlin Hard to maintain and evolve the compiler 2. Interaction with compiler and IDEs Many ad-hoc solutions, no strict contracts, and no stable API 3. Compilation time per f ormance
36. K2 : The new Kotlin compiler - why? 1. A few language features have appeared unexpectedly in Kotlin Hard to maintain and evolve the compiler 2. Interaction with compiler and IDEs Many ad-hoc solutions, no strict contracts, and no stable API 3. Compilation time per f ormance
37. K2 : The new Kotlin compiler - why? 1. A few language features have appeared unexpectedly in Kotlin Hard to maintain and evolve the compiler 2. Interaction with compiler and IDEs Many ad-hoc solutions, no strict contracts, and no stable API 3. Compilation time per f ormance
38. Kotlin 2.0 ( 2024 ) More than 80 features in the different subsystems Around 25 and small improvements within the language Main focus is on correctness and per f ormance
39. Kotlin 2.0 ( 2024 ) More than 80 features in the different subsystems Around 25 and small improvements within the language Main focus is on correctness and per f ormance
40. Frontend Intermediate Representation (FIR)
41. if (condition) { println("Hello") } when { condition -> println("Hello") } Frontend Intermediate Representation (FIR)
42. if (condition) { println("Hello") } when { condition -> println("Hello") } for (n in list) { println(n) } val <interator> = list.interator() while(<iterator>.hasNext()){ val s = <iterator>.next() println(s) } Frontend Intermediate Representation (FIR)
43. if (condition) { println("Hello") } when { condition -> println("Hello") } for (n in list) { println(n) } val <interator> = list.interator() while(<iterator>.hasNext()){ val s = <iterator>.next() println(s) } val (a, b) = "a" to "b" val <pair> = "a" to "b" val a = pair.component1() val b = pair.component2() Frontend Intermediate Representation (FIR)
44. fun mutate(ml: MutableList<Long>) { ml[0] = ml[0] + 1 } Combination of Long and Integer Literal Types Frontend Intermediate Representation (FIR)
45. fun mutate(ml: MutableList<Long>) { ml[0] = ml[0] + 1 } Combination of Long and Integer Literal Types Long Integer Literal Type Frontend Intermediate Representation (FIR)
46. fun mutate(ml: MutableList<Long>) { ml[0] += 1 } Combination of Long and Integer Literal Types Error: 1L is required // Error in Kotlin 1.x Frontend Intermediate Representation (FIR)
47. fun mutate(ml: MutableList<Long>) { ml[0] += 1 } Combination of Long and Integer Literal Types // OK in 2.0 Desugared into: ml.set(0, ml.get(0).plus(1)) Frontend Intermediate Representation (FIR)
48. Combination of nullable operator-calls class Box(val ml: MutableList<Long>) fun mutate(box: Box?) { box ?. ml[0] += 1 // Error in 1.x box ?. ml[0] += 1L // Error in 1.x } Frontend Intermediate Representation (FIR)
49. Combination of nullable operator-calls class Box(val ml: MutableList<Long>) fun mutate(box: Box?) { box ?. ml[0] += 1 // OK in 2.0 } box ?. run { ml.set(0, ml.get(0).plus(1))} Desugared into: Frontend Intermediate Representation (FIR)
50. New control flow engine read: more smar t -casts! - KT-7186 Smar t cast for captured variables inside changing closures of inline functions - KT-4113 Smar t casts for proper t ies to not-null functional types at invoke calls - KT-25747 DFA variables: propagate smar t cast results from local variables - KT-1982 Smar t cast to a common super t ype of subject types after || (OR operator) - .
51. Smar t -casts
52. class Cat { fun purr() { println("Purr purr") } } fun petAnimal(animal: Any) { if (animal is Cat) { animal.purr() } } Smar t -casts
53. class Cat { fun purr() { println("Purr purr") } } fun petAnimal(animal: Any) { if (animal is Cat) { animal.purr() } } Smar t -casts
54. class Cat { fun purr() { println("Purr purr") } } fun petAnimal(animal: Any) { val isCat = animal is Cat if (isCat) { animal.purr() } } Smar t -casts from variables
55. class Cat { fun purr() { println("Purr purr") } } fun petAnimal(animal: Any) { val isCat = animal is Cat if (isCat) { animal.purr() } } Smar t -casts from variables Kotlin 2.0 : synthetic data flow variables propagate information about smar t -casts
56. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } }
57. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } }
58. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } } Any -> Card Smar t -casted to Card
59. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } } Any -> Card String? -> String Smar t -casted to String Smar t -casted to Card
60. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } } Any -> Card String? -> String Smar t -casted to String Smar t -casted to Card String? -> String
61. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } }
62. Smar t -casts from variables class Card(val holder: String?) fun findHolder(card: Any): String { val cardWithHolder = card is Card && !card.holder.isNullOrEmpty() return when { cardWithHolder -> { card.holder } else -> "none" } } String
63. This slide is intentionally left blank
64. What's next for Kotlin?
65. What's next for Kotlin? More features are coming for working with data
66. What's next for Kotlin? More features are coming for working with data Stronger abstractions and improvements in the type system
67. What's next for Kotlin?
68. What's next for Kotlin?
69. What's next for Kotlin? 2.0 2.1 2.2 2.4
70. What's next for Kotlin? Guards: pattern matching without binding Context parameters 2.2 CheckReturnValue 2.2 Name-based destructuring 2.4 Rich errors 2.4 Beta Stable 2.2
71. when { order is YearlySubscription && order.amount > 100 -> applyDiscount(order) order is MonthlySubscription -> startSubscription(order) order is OneTimeOrder -> processOrder(order) } val order = getOrder()
72. when { order is YearlySubscription && order.amount > 100 -> applyDiscount(order) order is MonthlySubscription -> startSubscription(order) order is OneTimeOrder -> processOrder(order) } val order = getOrder() Potentially a logical error Repetition is not nice
73. when { order is YearlySubscription && order.amount > 100 -> applyDiscount(order) order is YearlySubscription -> processSubscription(order) order is MonthlySubscription -> startSubscription(order) order is OneTimeOrder -> processOrder(order) } val order = getOrder()
74. when(order) { is YearlySubscription && order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder()
75. when(order) { is YearlySubscription && order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder() Error: expecting ' -> ' &&
76. when(order) { is YearlySubscription && order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder() Guarded conditions: KEEP - 371 if
77. when(order) { is YearlySubscription if order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder()
78. when(order) { is YearlySubscription -> processSubscription(order) is YearlySubscription if order.amount > 100 -> applyDiscount(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder() 'when' branch is never reachable
79. when(order) { is YearlySubscription if order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder() 2.1
80. when(order) { is YearlySubscription if order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder() 2.1 2.2 Stabe
81. when(order) { is YearlySubscription if order.amount > 100 -> applyDiscount(order) is YearlySubscription -> processSubscription(order) is MonthlySubscription -> startSubscription(order) is OneTimeOrder -> processOrder(order) } val order = getOrder()
82. when(order) { is YearlySubscription if order.amount > 100 -> { val (id, name, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = getOrder() Destructuring
83. when(order) { is YearlySubscription if order.amount > 100 -> { val (id, name, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Destructuring Order 1: Anton, 12.0
84. when(order) { is YearlySubscription if order.amount > 100 -> { val (name, id, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Variable name 'id' matches the name of a different component Destructuring
85. when(order) { is YearlySubscription if order.amount > 100 -> { val (name, id, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Order Anton: 1, 12.0 Destructuring
86. when(order) { is YearlySubscription if order.amount > 100 -> { val (name, id, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Error: 'name' doesn’t match the proper t y 'customerName' Name-based destructuring
87. when(order) { is YearlySubscription if order.amount > 100 -> { val (name, id, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Name-based destructuring
88. when(order) { is YearlySubscription if order.amount > 100 -> { val (name, id, amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Name-based destructuring Existing syntax
89. when(order) { is YearlySubscription if order.amount > 100 -> { (val name, val id, val amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Name-based destructuring
90. when(order) { is YearlySubscription if order.amount > 100 -> { (val name, val id, val amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Name-based destructuring sealed interface Order data class YearlySubscription(val productName: String, ... ) : Order Does not rely on data classes
91. when(order) { is YearlySubscription if order.amount > 100 -> { (val name, val id, val amount) = order println("Order $id: $name $amount") } is YearlySubscription -> processSubscription(order) ... val order = YearlySubscription("1", "Anton", 12.0, 2024 OCTOBER 9) Name-based destructuring sealed interface Order data class YearlySubscription(val productName: String, ... ) : Order Experimental in 2.4 Does not rely on data classes
92. What's next for Kotlin? Guards: pattern matching without binding Context parameters 2.2 CheckReturnValue 2.2 Name-based destructuring 2.4 Rich errors 2.4 Beta Stable 2.2
93. Use case: type-safe builders (a.k.a DSLs)
94. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders (a.k.a DSLs)
95. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders (a.k.a DSLs) Functional literal with receiver
96. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders DSL library
97. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders DSL library buildClient { name = "Bob" birthday = LocalDate.of(2000, 3, 10) } User code
98. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders DSL library buildClient { name = "Bob" birthday = LocalDate.of(2000, 3, 10) } User code Can we do better?
99. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) val dob = 10 March 2000
100. class Client(var name: String? = null, var birthday: LocalDate? = null) fun buildClient(init: Client.() - > Unit): Client { var client = Client() client.init() return client } Use case: type-safe builders DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) val dob = 10 March 2000 How can we restrict the scope?
101. object ClientBuilderContext context(_: ClientBuilderContext) infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code val dob = 10 March 2000 Context parameters (KEEP - 367 )
102. DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code val dob = 10 March 2000 fun buildClient(init: context(ClientBuilderContext) Client.() - > Unit): Client = with(ClientBuilderContext()) { //. .. } object ClientBuilderContext context(_: ClientBuilderContext) infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) Context parameters (KEEP - 367 )
103. DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code val dob = 10 March 2000 fun buildClient(init: context(ClientBuilderContext) Client.() - > Unit): Client = with(ClientBuilderContext()) { //. .. } object ClientBuilderContext context(_: ClientBuilderContext) infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) Context parameters (KEEP - 367 )
104. DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code val dob = 10 March 2000 fun buildClient(init: context(ClientBuilderContext) Client.() - > Unit): Client = with(ClientBuilderContext()) { //. .. } object ClientBuilderContext context(_: ClientBuilderContext) infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) The required context is missing Required context available in this block Context parameters (KEEP - 367 )
105. DSL library buildClient { name = "Bob" birthday = 10 March 2000 } User code val dob = 10 March 2000 fun buildClient(init: context(ClientBuilderContext) Client.() - > Unit): Client = with(ClientBuilderContext()) { //. .. } object ClientBuilderContext context(_: ClientBuilderContext) infix fun Int.March(year: Int) = LocalDate.of(year, Month.MARCH, this) The required context is missing Required context available in this block Context parameters (KEEP - 367 ) Beta in 2.2
106. This slide is intentionally left blank
107. What's next for Kotlin? Guards: pattern matching without binding Context parameters 2.2 CheckReturnValue 2.2 Name-based destructuring 2.4 Rich errors 2.4 Beta Stable 2.2
108. Errors are a way to express that a method can fail using type system capabilities error object NotFound TL;DR: Errors != Exceptions
109. Errors are a way to express that a method can fail using type system capabilities error object NotFound TL;DR: Errors != Exceptions Experimental in 2.4
110. Toy example: nulls as errors
111. Toy example: nulls as errors
112. Toy example: nulls as errors
113. Toy example: nulls as errors
114. Toy example: sealed hierarchies
115. Toy example: sealed hierarchies
116. Toy example: sealed hierarchies
117. Toy example: sealed hierarchies
118. Toy example: sealed hierarchies
119. Toy example: Result
120. Toy example: Result
121. Toy example: original example
122. Rich errors New kind of classifiers
123. Rich errors
124. Rich errors
125. Rich errors
126. What about exceptions? • Kotlin don’t have checked exceptions for a purpose • Primary use exceptions should be for unrecoverable cases
127. What about exceptions? • Kotlin don’t have checked exceptions for a purpose • Primary use exceptions should be for unrecoverable cases From exceptions to errors:
128. What about exceptions? • Kotlin don’t have checked exceptions for a purpose • Primary use exceptions should be for unrecoverable cases From exceptions to errors:
129. This slide is intentionally left blank
130. What's next for Kotlin? Guards: pattern matching without binding Context parameters 2.2 CheckReturnValue 2.2 Name-based destructuring 2.4 Rich errors 2.4 Beta Stable 2.2
140. What do those examples have in common?
141. They do not use return value of the call. What do those examples have in common?
142. They do not use return value of the call. What do those examples have in common? Can we prevent this?
143. They do not use return value of the call. What do those examples have in common? Can we prevent this? Let's repor t every unused value!
144. They do not use return value of the call. What do those examples have in common? Can we prevent this? Let's repor t every unused value! Not always true, unfor t unately:
145. They do not use return value of the call. What do those examples have in common? Can we prevent this? Let's repor t every unused value! Not always true, unfor t unately: There are results which are supposed to be used and there are results which are auxiliary.
146. Existing solutions
147. Existing solutions
148. Existing solutions
149. CheckReturnValue as future default
150. CheckReturnValue as future default In Kotlin 2.2 : Kotlin stdlib and kotlinx libraries are marked with @MustUseReturnValue Opt-in to enable the checker
151. CheckReturnValue as future default In Kotlin 2.2 : Kotlin stdlib and kotlinx libraries are marked with @MustUseReturnValue Opt-in to enable the checker Next steps: More libraries Application code by default
152. What's next for Kotlin? Guards: pattern matching without binding Context parameters 2.2 CheckReturnValue 2.2 Name-based destructuring 2.4 Rich errors 2.4 Beta Stable 2.2
153. Summary Kotlin 2.0 : new compiler & more smar t -casts More features are coming for working with data Stronger abstractions and improvements in the type system
154. https://speakerdeck.com/antonarhipov