Idiomatic Kotlin, 2nd edition

@antonarhipov
Idiomatic Kotlin
2nd edition

View Slide

Anton Arhipov

@antonarhipov
Developer Advocate @ JetBrains

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
Effective use of
features

View Slide

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)

}

->
Unit) {

callback()

}

fun finishWork() {


}
Just functions,

no classes!

View Slide

fun main() {

doSomething()

}

fun doSomething() {

doMoreStuff(
:
:
finishWork)

}

->
Unit) {

callback()

}

fun finishWork() {


}
Grouping by
fi
les …

View Slide

Classical project
structure

View Slide

The project structure
simpli
fi
es

View Slide

We can simplify it even
more!

View Slide

Extensions

View Slide

Don’t create classes just to hold functions
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

Use extension functions
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.

Minimize API pollution, restrict the visibility.

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

)

View Slide



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



RowMapper { rs, _
->


},

id

)

View Slide



id,

RowMapper { rs, _
->


}

)

View Slide



id,

{ rs, _
->


}

)

View Slide



id)

{ rs, _
->


}

View Slide


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


}

View Slide


"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)

View Slide

Scope functions
apply, let, run, also, with

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().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){


}
retrieveOrder()
?.
let {

processCustomer(it.customer)

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

View Slide


if (order
!=
null){


}
retrieveOrder()
?.
let {


}
No extra variable
retrieveOrder()
?.
let {


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

View Slide

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
try, if, when

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

View Slide

Use try as expression body
fun tryParse(number: String) : Int? {

try {

return Integer.parseInt(number)

} catch (e: NumberFormatException) {

return null

}

}

View Slide

Use try as expression body
fun tryParse(number: String) = try {

Integer.parseInt(number)


null

}

View Slide

Use try as expression
fun tryParse(number: String) : Int? {

val n = try {

Integer.parseInt(number)


null

}

println(n)

return n

}

View Slide

Null-safety

View Slide

class Nullable {

fun someFunction(){}

}

fun createNullable(): Nullable? = null

fun main() {

val n: Nullable? = createNullable()

n.someFunction()

}

View Slide

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

Functional types

View Slide

fun someFunction(function: ()
->
T): T {

…

}

View Slide

->
T): T {

…

}

Functional type

View Slide

->
T): T {

…

}

fun someOtherFunction(){

val s: String = someFunction { "Hello" }

}

View Slide

fun someFunction(function: Action): T {

…

}


val s: String = someFunction { "Hello" }

}

typealias Action = ()
->
T

View Slide

->
T

View Slide

->
T
class MyAction : Action {

override fun invoke(): T {

TODO("Not yet implemented")

}

}

View Slide

->
T
class MyAction : Action {



}

}


…

}

View Slide

->
T
class MyAction(val param: String) : Action {



}

}


…

}


val s: String = someFunction(MyAction("Greetings"))

}

View Slide

It’s not enough for the programming language to provide
higher-order functions.

We need other tools for working with these!
Observation:

View Slide

It’s not enough for the programming language to provide
FEATURE.

We need other tools for working with FEATURE!
General observation:

View Slide

Ranges

View Slide

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

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

View Slide

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

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

Destructuring

View Slide

Return multiple values using data classes
fun namedNum(): Pair =

1 to "one"

//
same but shorter

fun namedNum2() = 1 to "one"


val pair = namedNum()

val number = pair.first

val name = pair.second

}

View Slide

fun namedNum(): Pair =

1 to "one"

//
same but shorter

fun namedNum2() = 1 to "one"


val pair = namedNum()

val number = pair.first

val name = pair.second

}
data class GameResult(

val rank: Int,

val name: String

)

fun namedNum() =

GameResult(1, "Player 1")


val (rank, name) = namedNum()

println("$name, rank $rank")

}

View Slide

data class GameResult(

val rank: Int,

val name: String

)

fun namedNum() =

GameResult(1, "Player 1")


val (rank, name) = namedNum()

println("$name, rank $rank")

}
GameResult var1 = namedNum();

int var2 = var1.component1();

String var3 = var1.component2();

View Slide

Destructuring in loops
fun printMap(map: Map) {

for (item in map.entries) {

println("${item.key}
->
${item.value}")

}

}

View Slide

Destructuring in loops

for (item in map.entries) {

println("${item.key}
->
${item.value}")

}

}

for ((key, value) in map) {

println("$key
->
$value")

}

}

View Slide

Destructuring in lists
data class NameExt(

val name: String,

val ext: String?

)

fun splitNameExt(filename: String): NameExt {

if ('.' in filename) {

val parts = filename.split('.', limit = 2)

return NameExt(parts[0], parts[1])

}

return NameExt(filename, null)

}

fun splitNameAndExtension(filename: String): NameExt {

if ('.' in filename) {

val (name, ext) = filename.split('.', limit = 2)

return NameExt(name, ext)

}

return NameExt(filename, null)

}

View Slide

View Slide

Standard library

View Slide

View Slide

Idiomatic Kotlin

View Slide

Standard library

View Slide

Kotlin for backend
development

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)




}


}

Transforming data
Calculating the result

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) }
val step2 = step1.sumOf { it.reduce { a, b
- >
a intersect b }.count() }
Transforming data
groups.map { group
->

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

}.sumOf { answerSets
->

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

}

View Slide

Select objects by type with filterIsInstance
fun findAllStrings(objects: List) =

objects.filter { it is String }

View Slide




objects.filterIsInstance()

View Slide

fun findAllStrings(objects: List) : List =


fun findAllStrings(objects: List) : List =

objects.filterIsInstance()

View Slide

compareBy compares by multiple keys
class Person(

val name: String,

val age: Int

)

fun sortPersons(persons: List) =

persons.sortedWith(Comparator { person1, person2
->

val rc = person1.name.compareTo(person2.name)

if (rc
!=
0)

rc

else

person1.age - person2.age

})

View Slide

compareBy compares by multiple keys
class Person(

val name: String,

val age: Int

)


persons.sortedWith(Comparator { person1, person2
->

val rc = person1.name.compareTo(person2.name)

if (rc
!=
0)

rc

else

person1.age - person2.age

})


persons.sortedWith(compareBy(Person
::
name, Person
:
:
age))

View Slide

groupBy to group elements
class Request(

val url: String,

val remoteIP: String,

val timestamp: Long

)

fun analyzeLog(log: List) {

val map = mutableMapOf>>
()

for (request in log) {

map.getOrPut(request.url) { mutableListOf() }

.add(request)

}

}

View Slide

groupBy to group elements
class Request(

val url: String,

val remoteIP: String,

val timestamp: Long

)


val map = mutableMapOf>>
()

for (request in log) {

map.getOrPut(request.url) { mutableListOf() }

.add(request)

}

}


val map = log.groupBy(Request
::
url)

}

View Slide

Use coerceIn to ensure numbers in range
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)

}

View Slide

Initializing objects with apply
)

{

maxTotal = 40
maxIdle = 40
minIdle = 4
}

View Slide

final ClientBuilder builder = new ClientBuilder();

builder.setFirstName("Anton");

builder.setLastName("Arhipov");

final TwitterBuilder twitterBuilder = new TwitterBuilder();

twitterBuilder.setHandle("@antonarhipov");

builder.setTwitter(twitterBuilder.build());

final CompanyBuilder companyBuilder = new CompanyBuilder();

companyBuilder.setName("JetBrains");

companyBuilder.setCity("Tallinn");

builder.setCompany(companyBuilder.build());

final Client client = builder.build();

System.out.println("Created client is: " + client);

View Slide

val builder = ClientBuilder()

builder.firstName = "Anton"

builder.lastName = "Arhipov"

val twitterBuilder = TwitterBuilder()

twitterBuilder.handle = "@antonarhipov"

builder.twitter = twitterBuilder.build()

val companyBuilder = CompanyBuilder()

companyBuilder.name = "JetBrains"

companyBuilder.city = "Tallinn"

builder.company = companyBuilder.build()

val client = builder.build()

println("Created client is: $client")

View Slide


builder.firstName = "Anton"

builder.lastName = "Arhipov"

val twitterBuilder = TwitterBuilder()

twitterBuilder.handle = "@antonarhipov"

builder.twitter = twitterBuilder.build()

val companyBuilder = CompanyBuilder()

companyBuilder.name = "JetBrains"

companyBuilder.city = "Tallinn"

builder.company = companyBuilder.build()

val client = builder.build()


val client = ClientBuilder().apply {

firstName = "Anton"

lastName = "Arhipov"

twitter = TwitterBuilder().apply {

handle = "@antonarhipov"

}.build()

company = CompanyBuilder().apply {

name = "JetBrains"

city = "Tallinn"

}.build()

}.build()


View Slide

Domain Specific Languages

View Slide

buildString
//Java
String name = "Joe";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 5; i++) {
sb.append("Hello, ");
sb.append(name);
sb.append("!\n");
}
System.out.println(sb);
//Kotlin
val name = "Joe"
val s = buildString {
repeat(5) {
append("Hello, ")
append(name)
appendLine("!")
}
}
println(s)

View Slide

kotlinx.html
System.out.appendHTML().html {

body {

div {

a("http:
//
kotlinlang.org") {

target = ATarget.blank

+"Main site"

}

}

}

}

View Slide

Ktor
fun main() {

embeddedServer(Netty, port = 8080, host = "0.0.0.0") {

routing {

get("/html-dsl") {

call.respondHtml {

body {

h1 { +"HTML" }

ul {

for (n in 1
..
10) {

li { +"$n" }

}

}

}

}

}

}

}.start(wait = true)

}

View Slide

Ktor
fun main() {


routing {

get("/html-dsl") {

call.respondHtml {

body {

h1 { +"HTML" }

ul {

for (n in 1
..
10) {

li { +"$n" }

}

}

}

}

}

}


}

Ktor’s routing

View Slide

Ktor
fun main() {


routing {

get("/html-dsl") {

call.respondHtml {

body {

h1 { +"HTML" }

ul {

for (n in 1
..
10) {

li { +"$n" }

}

}

}

}

}

}


}

kotlinx.html
Ktor’s routing

View Slide

Lambda with receiver
T.() -> Unit

View Slide

Build your vocabulary to abstract from scope functions

firstName = "Anton"




}.build()


name = "JetBrains"

city = "Tallinn"

}.build()

}.build()


View Slide

fun client(c: ClientBuilder.()
- >
Unit): Client {


c(builder)

return builder.build()

}

fun ClientBuilder.company(block: CompanyBuilder.()
- >
Unit) {

company = CompanyBuilder().apply(block).build()

}

fun ClientBuilder.twitter(block: TwitterBuilder.()
- >
Unit) {

twitter = TwitterBuilder().apply(block).build()

}

firstName = "Anton"




}.build()


name = "JetBrains"

city = "Tallinn"

}.build()

}.build()


View Slide

val client = client {

firstName = "Anton"


twitter {


}

company {

name = "JetBrains"

city = "Tallinn"

}

}



firstName = "Anton"




}.build()


name = "JetBrains"

city = "Tallinn"

}.build()

}.build()


View Slide

https://speakerdeck.com/antonarhipov
@antonarhipov

View Slide

Idiomatic Kotlin, 2nd edition

Idiomatic Kotlin, 2nd edition

Anton Arhipov

More Decks by Anton Arhipov

Other Decks in Programming

Featured

Transcript