Idiomatic Kotlin - IntelliJ IDEA Conf 2022

Idiomatic Kotlin

View Slide

@antonarhipov

View Slide

View Slide

Idiomatic - using, containing, or denoting
expressions that are natural to a native speaker

View Slide

Commonly
accepted style

View Slide

Commonly
accepted style
E
ff
ective use of
language features

View Slide

Top-Level (Extension) Functions

View Slide

fun main() {

doSomething()

}

fun doSomething() {

doMoreStuff(
:
:
finishWork)

}

fun doMoreStuff(callback: ()
->
Unit) {

callback()

}

fun finishWork() {

TODO("Not implemented yet")

}

View Slide

fun main() {

doSomething()

}

fun doSomething() {

doMoreStuff(
:
:
finishWork)

}

fun doMoreStuff(callback: ()
->
Unit) {

callback()

}

fun finishWork() {

TODO("Not implemented yet")

}
Just functions,

no classes!

View Slide

Don’t create classes

just to hold functions!

View Slide

class StringUtils {

companion object {

fun isPhoneNumber(s: String) =

s.length
=
=
7
&
&
s.all { it.isDigit() }

}

}

View Slide

class StringUtils {

companion object {


s.length
=
=
7
&
&

}

}

object StringUtils {


s.length
=
=
7
&
&

}

View Slide

class StringUtils {

companion object {


s.length
=
=
7
&
&

}

}



s.length
=
=
7
&
&

}


s.length
==
7
&&

View Slide

class StringUtils {

companion object {


s.length
=
=
7
&
&

}

}



s.length
=
=
7
&
&

}


s.length
==
7
&&

fun String.isPhoneNumber() =

length
==
7
&&
all { it.isDigit() }

View Slide

Extension or a member?
https://kotlinlang.org/docs/coding-conventions.html#extension-functions
Use extension functions liberally

Restrict the visibility to minimize API pollution

As necessary, use local extension functions, member
extension functions, or top-level extension functions with
private visibility

View Slide

+

View Slide

fun findMessageById(id: String) =

db.query(

"select * from messages where id = ?",

RowMapper { rs, _
->

Message(rs.getString("id"), rs.getString("text"))

},

id

)
val db: JdbcTemplate =
...

View Slide


db.query(


RowMapper { rs, _
->


},

id

)
@Override

public List query(String sql, RowMapper rowMapper, @Nullable Object
.
..
args)

throws DataAccessException {

return result(query(sql, args, new RowMapperResultSetExtractor
<
>
(rowMapper)));

}

View Slide


db.query(


RowMapper { rs, _
->


},

id

)

View Slide


db.query(


id,

RowMapper { rs, _
->


}

)
vararg

View Slide


db.query(


id,

{ rs, _
->


}

)
SAM conversion

View Slide


db.query(


id)

{ rs, _
->


}

Trailing lambda parameter

View Slide


db.query("select * from messages where id = ?", id ) { rs, _
->


}

View Slide


db.query("select * from messages where id = ?", id ) { rs, _
->


}
fun JdbcOperations.query(sql: String, vararg args: Any, function: (ResultSet, Int)
->
T): List =

query(sql, RowMapper { rs, i
->
function(rs, i) }, *args)
Extension function!

View Slide

Summary

Functions, Extensions,
Trailing lambda,Varargs,
SAM conversion

View Slide

Scope functions

View Slide

View Slide

val dataSource = BasicDataSource()
dataSource.driverClassName = "com.mysql.jdbc.Driver"
dataSource.url = "jdbc:mysql://domain:3309/db"
dataSource.username = "username"
dataSource.password = "password"
dataSource.maxTotal = 40
dataSource.maxIdle = 40
dataSource.minIdle = 4

View Slide

val dataSource = BasicDataSource()
dataSource.driverClassName = "com.mysql.jdbc.Driver"
dataSource.url = "jdbc:mysql://domain:3309/db"
dataSource.username = "username"
dataSource.password = "password"
dataSource.maxTotal = 40
dataSource.maxIdle = 40
dataSource.minIdle = 4
val dataSource = BasicDataSource().apply {
driverClassName = "com.mysql.jdbc.Driver"
url = "jdbc:mysql://domain:3309/db"
username = "username"
password = "password"
maxTotal = 40
maxIdle = 40
minIdle = 4
}

View Slide

maxTotal = 40
maxIdle = 40
minIdle = 4
}
public inline fun T.apply(block: T.()
->
Unit): T {

block()

return this

}

View Slide

maxTotal = 40
maxIdle = 40
minIdle = 4
}
public inline fun T.apply(block: T.()
->
Unit): T {

block()

return this

}

Lambda with receiver

View Slide

?.let
val order = retrieveOrder()

if (order
!=
null){

processCustomer(order.customer)

}

View Slide


if (order
!=
null){

processCustomer(order.customer)

}
retrieveOrder()
?.
let {

processCustomer(it.customer)

}
retrieveOrder()
?.
customer
?.
let {
::
processCustomer }
or
?.let

View Slide

View Slide

fun makeDir(path: String) = path.let { File(it) }.also { it.mkdirs() }

View Slide

Don’t overuse the scope functions!

View Slide

fun makeDir(path: String) : File {

val file = File(path)

file.mkdirs()

return file

}

This is simpler!

View Slide

fun makeDir(path: String) : File {

val file = File(path)

file.mkdirs()

return file

}

This is simpler!
fun makeDir(path: String) = File(path).also { it.mkdirs() }
OK, this one is actually
fi
ne :)

View Slide

Default argument values and named parameters

View Slide

fun find(name: String){

find(name, true)

}

fun find(name: String, recursive: Boolean){

}
Function

overloading

View Slide


find(name, true)

}


}
fun find(name: String, recursive: Boolean = true){

}
Default
argument value
Function

overloading

View Slide


find(name, true)

}


}
fun find(name: String, recursive: Boolean = true){

}
fun main() {

find("myfile.txt")

}
Default
argument value
Function

overloading

View Slide

class Figure(

val width: Int = 1,

val height: Int = 1,

val depth: Int = 1,

color: Color = Color.BLACK,

description: String = "This is a 3d figure",

)
Figure(Color.RED, "Red figure")

View Slide

class Figure(

val width: Int = 1,


val depth: Int = 1,



)
Figure(Color.RED, "Red figure") Compilation error

View Slide

class Figure(

val width: Int = 1,


val depth: Int = 1,



)
Figure(color = Color.RED, description = "Red figure")

View Slide

Default argument values diminish the need

for overloading in most cases.

View Slide

Default argument values diminish the need

for overloading in most cases.
Named parameters is a necessary tool for

working with default argument values

View Slide

Expressions
if
when
try

View Slide

fun adjustSpeed(weather: Weather): Drive {

val result: Drive

if (weather is Rainy) {

result = Safe()

} else {

result = Calm()

}

return result

}

View Slide


val result: Drive = if (weather is Rainy) {

Safe()

} else {

Calm()

}

return result

}

View Slide


return if (weather is Rainy) {

Safe()

} else {

Calm()

}

}

View Slide

fun adjustSpeed(weather: Weather): Drive = if (weather is Rainy) {

Safe()

} else {

Calm()

}

View Slide

fun adjustSpeed(weather: Weather) = if (weather is Rainy) {

Safe()

} else {

Calm()

}

View Slide

fun adjustSpeed(weather: Weather) = if (weather is Rainy) Safe() else Calm()

Is it concise?
Sure!

View Slide


Is it readable?
It depends!

View Slide


What does the function
return?

View Slide

fun adjustSpeed(weather: Weather): Drive =
...

fun adjustSpeed(weather: Weather) =
...
For public API, keep the
return type in the
signature
For private API it is
generally OK to use type
inference

View Slide


View Slide

abstract class Weather

class Sunny : Weather()

class Rainy : Weather()

fun adjustSpeed(weather: Weather) = when (weather) {

is Rainy
->
Safe()

else
->
Calm()

}

View Slide

sealed class Weather




is Rainy
->
Safe()

/ /
else
->
Calm()

}

View Slide





is Rainy
->
Safe()

is Sunny
->
TODO()

}

View Slide





is Rainy
->
Safe()

is Sunny
->
TODO()

}

Use expressions!

Use when as expression body

Use sealed classes with when

View Slide

Null-safety

View Slide

class Nullable {

fun someFunction(){}

}

fun createNullable(): Nullable? = null

fun main() {

val n: Nullable? = createNullable()

n.someFunction()

}

View Slide

Consider using null-safe call

if (order
==
null
||
order.customer
= =
null
||
order.customer.address
==
null){

throw IllegalArgumentException("Invalid Order")

}

val city = order.customer.address.city

View Slide


val city = order
?.
customer
? .
address
?.
city

View Slide


val city = order
?.
customer
? .
address
?.
city

?:
throw IllegalArgumentException("Invalid Order")


View Slide

Avoid not-null assertions
!
!

val city = order
!!
.customer
!!
.address
!!
.city

“You may notice that the double exclamation mark looks a bit rude:
it’s almost like you’re yelling at the compiler. This is intentional.” - Kotlin in Action

View Slide

!
!
class MyTest {

class State(val data: String)

private var state: State? = null

@BeforeEach

fun setup() {

state = State("abc")

}

@Test

fun foo() {

assertEquals("abc", state
!!
.data)

}

}

View Slide

!
!
class MyTest {


private var state: State? = null

@BeforeEach

fun setup() {


}

@Test

fun foo() {

assertEquals("abc", state
!!
.data)

}

}
class MyTest {


private lateinit var state: State

@BeforeEach

fun setup() {


}

@Test

fun foo() {

assertEquals("abc", state.data)

}

}
- use lateinit

View Slide

View Slide

Use elvis operator
class Person(val name: String?, val age: Int?)

val p = retrievePerson()
?:
Person()

View Slide

Use elvis operator as return and throw

fun processPerson(person: Person) {

val name = person.name

if (name
= =
null)

throw IllegalArgumentException("Named required")

val age = person.age

if (age
==
null) return

println("$name: $age")

}

View Slide

Use elvis operator as return and throw

fun processPerson(person: Person) {

val name = person.name
? :

throw IllegalArgumentException("Named required")

val age = person.age
?:
return

println("$name: $age")

}

View Slide

Consider using safe cast for type checking
override fun equals(other: Any?) : Boolean {

val command = other as Command

return command.id
==
id

}

View Slide

Consider using safe cast for type checking

val command = other as Command

return command.id
==
id

}

return (other as? Command)
?.
id
==
id

}

View Slide

Ranges

View Slide

Use range checks instead of comparison pairs
fun isLatinUppercase(c: Char) =

c
>
=
'A'
&&
c
< =
'Z'

View Slide


c
>
=
'A'
&&
c
< =
'Z'


View Slide


c in 'A'
.
.
'Z'

View Slide

class Version(val major: Int, val minor: Int): Comparable {

override fun compareTo(other: Version): Int {

if (this.major
!=
other.major) {

return this.major - other.major

}

return this.minor - other.minor

}

}

fun main() {

val versionRange = Version(1, 11)
.
.
Version(1, 30)

println(Version(0, 9) in versionRange)


}

Comparable range

View Slide

class Version(val major: Int, val minor: Int): Comparable {

override fun compareTo(other: Version): Int {

if (this.major
!=
other.major) {

return this.major - other.major

}

return this.minor - other.minor

}

}

fun main() {

val versionRange = Version(1, 11)
.
.
Version(1, 30)



}

Comparable range
public operator fun >
>
T.rangeTo(that: T): ClosedRange

= ComparableRange(this, that)

View Slide

Ranges in loops
fun main(args: Array) {

for (i in 0
..
args.size - 1) {

println("$i: ${args[i]}")

}

}

View Slide

Ranges in loops

for (i in 0
..
args.size - 1) {


}

}

for (i in 0 until args.size) {


}

View Slide

Ranges in loops

for (i in 0
..
args.size - 1) {


}

}



}
for (i in args.indices) {


}

View Slide

Ranges in loops

for (i in 0
..
args.size - 1) {


}

}



}
for (i in args.indices) {


}
for ((i, arg) in args.withIndex()) {

println("$i: $arg")

}

View Slide

View Slide

Standard library

View Slide

abcd

bcde

cdef

defg

xya

xyb

xyc

Group 1:
Group 2:
Count the total of characters that are present

on each line in every group of strings

View Slide

abcd

bcde

cdef

defg

xya

xyb

xyc

Group 1:
Group 2:
{d}

{xy}



View Slide

abcd

bcde

cdef

defg

xya

xyb

xyc

Group 1:
Group 2:
{d}

{xy}

count = 1

count = 2



View Slide

abcd

bcde

cdef

defg

xya

xyb

xyc

Group 1:
Group 2:
{d}

{xy}

count = 1

count = 2

Total = 3


View Slide

val input = """

abcd

bcde

cdef

defg

xya

xyb

xyc

""".trimIndent()

View Slide

val input = """

abcd

bcde

cdef

defg

xya

xyb

xyc

""".trimIndent()
val groups: List = input.split("\n\n")

View Slide

val input = """

abcd

bcde

cdef

defg

xya

xyb

xyc

""".trimIndent()
var total = 0

for (group in groups) {

val listOfSets: List>>

= group.split("\n").map(String
::
toSet)

var result = listOfSets.first()

for (set in listOfSets) {

result = result intersect set

}

total += result.count()

}

View Slide

val input = """

abcd

bcde

cdef

defg

xya

xyb

xyc

""".trimIndent()
var total = 0



::
toSet)




}


}

Transforming data

View Slide

val input = """

abcd

bcde

cdef

defg

xya

xyb

xyc

""".trimIndent()
var total = 0



::
toSet)




}


}

Calculating the result
Transforming data

View Slide


View Slide

//
List>>>

val step1 = groups.map { it.split("\n").map(String
::
toSet) }
Transforming data

View Slide

//
List>>>

::
toSet) }
val step2 = step1.sumOf { it.reduce { a, b
- >
a intersect b }.count() }
Transforming data

View Slide

//
List>>>

::
toSet) }
- >
Transforming data

View Slide

//
List>>>

::
toSet) }
- >
groups.map { group
->

group.split(nl).map(String
::
toSet)

}.sumOf { answerSets
->

answerSets.reduce { a, b
->
a intersect b }.count()

}

Transforming data

View Slide

View Slide

kotlin {

twitter = "@kotlin"

youtube = "youtube.com/kotlin"

slack = "slack.kotl.in"

}

me {

name = "Anton Arhipov"

twitter = "@antonarhipov"

slides = "speakerdeck.com/antonarhipov"

}

View Slide

Idiomatic Kotlin - IntelliJ IDEA Conf 2022

Idiomatic Kotlin - IntelliJ IDEA Conf 2022

Anton Arhipov

More Decks by Anton Arhipov

Other Decks in Programming

Featured

Transcript