Idiomatic Kotlin

Idiomatic Kotlin
Dmitry Jemerov <yole@jetbrains.com>

Use ‘when’ as expression body
fun parseNum(number: String): Int? {
when (number) {
"one" -> return 1
"two" -> return 2
else -> return null
}
}

Use ‘when’ as expression body
fun parseNum(number: String): Int? {
when (number) {
"one" -> return 1
"two" -> return 2
else -> return null
}
}
fun parseNum(number: String) =
when (number) {
"one" -> 1
"two" -> 2
else -> null
}

Use ‘try’ as expression body
fun tryParse(number: String): Int? {
try {
return Integer.parseInt(number)
}
catch (e: NumberFormatException) {
return null
}
}

Use ‘try’ as expression body
try {
}
return null
}
}
fun tryParse(number: String) =
try {
Integer.parseInt(number)
}
null
}

Use ‘try’ as expression
try {
}
return null
}
}
val n = try {
Integer.parseInt(number)
} catch (e: NumberFormatException) {
null
}
println(n)
return n
}

Use elvis with ‘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")
}
class Person(val name: String?,
val age: Int?)

Use elvis with ‘return’ and ‘throw’
val name = person.name
if (name == null)
throw IllegalArgumentException( 
"Named required")
val age = person.age
if (age == null) return
}
val name = person.name ?:
throw IllegalArgumentException(
"Name required")
val age = person.age ?: return
}
class Person(val name: String?,
val age: Int?)

Use range checks instead of comparison pairs
fun isLatinUppercase(c: Char) =
c >= 'A' && c <= 'Z'

Use range checks instead of comparison pairs
c >= 'A' && c <= 'Z'
c in 'A'..'Z'

Don’t create classes just to put functions in
class StringUtils {
companion object {
fun isPhoneNumber(s: String) =
s.length == 7 &&
s.all { it.isDigit() }
}
}

class StringUtils {
companion object {
s.length == 7 &&
}
}
object StringUtils {
s.length == 7 &&
}

class StringUtils {
companion object {
s.length == 7 &&
}
} fun isPhoneNumber(s: String) =
s.length == 7 &&
object StringUtils {
s.length == 7 &&
}

Use extension functions copiously
s.length == 7 &&

Use extension functions copiously
s.length == 7 &&
fun String.isPhoneNumber() =
length == 7 &&
all { it.isDigit() }

Avoid using member extension functions  
(unless required for DSLs)
class PhoneBook {
length == 7 &&
}

Avoid using member extension functions  
(unless required for DSLs)
class PhoneBook {
length == 7 &&
}
class PhoneBook {
}
private fun
String.isPhoneNumber() =
length == 7 &&

Don't use member extensions with  
containing class as the receiver
class PhoneBook {
fun PhoneBook.find(name: String)=
"1234567"
}

Don't use member extensions with  
containing class as the receiver
class PhoneBook {
fun PhoneBook.find(name: String)=
"1234567"
}
class PhoneBook {
fun find(name: String) =
"1234567"
}

Consider extracting non-essential API 
of classes into extensions
class Person(val firstName: String,
val lastName: String) {
val fullName: String
get() = "$firstName $lastName"
}

Consider extracting non-essential API 
of classes into extensions
val lastName: String) {
val fullName: String
}
val lastName: String)
val Person.fullName: String

Use default parameter values instead of overloads
wherever possible
class Phonebook {
fun print() {
print(",")
}
fun print(separator: String) {
}
}
fun main(args: Array<String>) {
Phonebook().print("|")
}

Use default parameter values instead of overloads
wherever possible
class Phonebook {
fun print() {
print(",")
}
fun print(separator: String) {
}
}
Phonebook().print("|")
}
class Phonebook {
fun print( 
separator: String = ",") {
}
}
Phonebook().print(
separator = "|")
}

Use ‘lateinit’ for properties that can’t be initialised
in a constructor
class MyTest {
class State(val data: String)
var state: State? = null
@Before fun setup() {
state = State("abc")
}
@Test fun foo() {
Assert.assertEquals( 
"abc", state!!.data)
}
}

Use ‘lateinit’ for properties that can’t be initialised
in a constructor
class MyTest {
var state: State? = null
}
@Test fun foo() {
"abc", state!!.data)
}
}
class MyTest {
lateinit var state: State
}
@Test fun foo() {
"abc", state.data)
}
}

Use type aliases for functional types and
collections
class EventDispatcher {
fun addClickHandler( 
handler: (Event) -> Unit) {
}
fun removeClickHandler(
}
}

collections
}
}
}
typealias ClickHandler =
(Event) -> Unit
fun addClickHandler(
handler: ClickHandler) {
}
handler: ClickHandler) {
}
}

collections
}
}
}
typealias ClickHandler =
(Event) -> Unit
typealias HandlerMap =
Map<EventType, List<Event>>

Use data classes to return multiple values
fun namedNum(): Pair<Int, String> =
1 to "one"
val pair = namedNum()
val number = pair.first
val name = pair.second
}

Use data classes to return multiple values
fun namedNum(): Pair<Int, String> =
1 to "one"
val pair = namedNum()
val number = pair.first
val name = pair.second
}
data class NamedNumber(
val number: Int,
val name: String)
fun namedNum() =
NamedNumber(1, "one")
val (number, name) = 
namedNum()
}

Use destructuring in loops
fun printMap(m: Map<String, String>) {
for (e in m.entries) {
println("${e.key} -> ${e.value}")
}
}

Use destructuring in loops
for (e in m.entries) {
println("${e.key} -> ${e.value}")
}
}
for ((key, value) in m) {
println("$key -> $value")
}
}

Use destructuring with lists
fun splitNameExt(fn: String): NameExt {
if ('.' in fn) {
val parts = fn.split('.', limit = 2)
return NameExt(parts[0], parts[1])
}
return NameExt(fn, null)
}
data class NameExt(val name: String,
val ext: String?)

Use destructuring with lists
if ('.' in fn) {
val parts = fn.split('.', limit = 2)
return NameExt(parts[0], parts[1])
}
}
if ('.' in fn) {
val (name, ext) =
fn.split('.', limit = 2)
return NameExt(name, ext)
}
}
data class NameExt(val name: String,
val ext: String?)

Use ‘copy’ method for data classes
class Person(val name: String,
var age: Int)
fun happyBirthday(person: Person) {
person.age++
}

Use ‘copy’ method for data classes
var age: Int)
fun happyBirthday(person: Person) {
person.age++
}
data class Person(val name: String,
val age: Int)
fun happyBirthday(person: Person) =
person.copy(
age = person.age + 1)

Use ‘coerceIn’ to ensure a number is in range
fun updateProgress(value: Int) {
val newValue = when {
value < 0 -> 0
value > 100 -> 100
else -> value
}
}

Use ‘coerceIn’ to ensure a number is in range
val newValue = when {
value < 0 -> 0
value > 100 -> 100
else -> value
}
}
val newValue =  
value.coerceIn(0, 100)
}

Use ‘apply’ for object initialisation
fun createLabel(): JLabel {
val label = JLabel("Foo")
label.foreground = Color.RED
label.background = Color.BLUE
return label
}

Use ‘apply’ for object initialisation
fun createLabel(): JLabel {
val label = JLabel("Foo")
label.foreground = Color.RED
label.background = Color.BLUE
return label
}
fun createLabel() =
JLabel("Foo").apply {
foreground = Color.RED
background = Color.BLUE
}

Use ‘ﬁlterIsInstance’ to ﬁlter a list by object type
fun findStrings(objs: List<Any>) =
objs.filter { it is String }

Use ‘ﬁlterIsInstance’ to ﬁlter a list by object type
objs.filter { it is String }
obs.filterIsInstance<String>()

Use ‘mapNotNull’ to apply a function and select
items for which it returns a non-null value
fun listErrors( 
results: List<Result>) =
results
.map { it.error }
.filterNotNull()
data class Result(val data: Any?,
val error: String?)

Use ‘mapNotNull’ to apply a function and select
items for which it returns a non-null value
fun listErrors( 
results
.map { it.error }
.filterNotNull()
fun listErrors(
results.mapNotNull {  
it.error
}
data class Result(val data: Any?,
val error: String?)

Use ‘compareBy’ for multi-step comparisons
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
})
val age: Int)

Use ‘compareBy’ for multi-step comparisons
persons.sortedWith(
Comparator<Person> { p1, p2 ->
val rc =
p1.name.compareTo(p2.name)
if (rc != 0)
rc
else
p1.age - p2.age
})
persons.sortedWith(
compareBy(Person::name,
Person::age))
val age: Int)

Use ‘groupBy’ to group items in a collection
fun analyzeLog(log: List<Request>) {
val map = mutableMapOf<String,
MutableList<Request>>()
for (request in log) {
map.getOrPut(request.url)
{ mutableListOf() }
.add(request)
}
}
class Request(val url: String,
val remoteIP: String,
val timestamp: Long)

Use ‘groupBy’ to group items in a collection
val map = mutableMapOf<String,
MutableList<Request>>()
for (request in log) {
map.getOrPut(request.url)
{ mutableListOf() }
.add(request)
}
}
val map = log.groupBy(Request::url)
}
class Request(val url: String,
val remoteIP: String,
val timestamp: Long)

Use String methods for string parsing
val pattern = Regex("(.+)/([^/]*)")
fun splitPath(path: String): PathParts {
val match = pattern.matchEntire(path)
?: return PathParts("", path)
return PathParts(match.groupValues[1],
match.groupValues[2])
}
data class PathParts(val dir: String,
val name: String)

Use String methods for string parsing
val pattern = Regex("(.+)/([^/]*)")
fun splitPath(path: String): PathParts {
val match = pattern.matchEntire(path)
?: return PathParts("", path)
return PathParts(match.groupValues[1],
match.groupValues[2])
}
fun splitPath(path: String) =
PathParts(
path.substringBeforeLast('/', ""),
path.substringAfterLast(‘/'))
data class PathParts(val dir: String,
val name: String)

Q&A
yole@jetbrains.com
@intelliyole

Idiomatic Kotlin

More Related Content

What's hot

Similar to Idiomatic Kotlin

Recently uploaded

Idiomatic Kotlin