1. https://kotlinlang.org/docs/reference/idioms.html#string-interpolation

   Code Block
   println("Name $name")

   
   

2. Prefer read-only `val` over mutable `var`
   

   Code Block
   /* bad */ var counter = 0 for(i in 0..20){ counter += i } /* preferred */ val sum = (0..20).sum()

   
   

3. Unit as a return type

   Code Block
   fun doSomething(): Unit{ println("do something") }

   
   

4. https://kotlinlang.org/docs/reference/idioms.html#single-expression-functions

   Code Block
   fun theAnswer() = 42

   
   

5. https://kotlinlang.org/docs/reference/idioms.html#default-values-for-function-parameters

   Code Block
   fun foo(a: Int = 0, b: String = "") { ... }

   
   

6. https://kotlinlang.org/docs/reference/idioms.

1. html#creating-

1. a-

1. singleton

   Code Block

1. object Resource { val name = "Name" }

   
   

2. https://kotlinlang.org/docs/reference/idioms.

1. html#instance-

1. checks

   Code Block

1. when

1. (x) {

1. is Foo -> ... is Bar -> ... else -> ... }

   
   

2. https://kotlinlang.org/docs/reference/idioms.html#creating-dtos-pojospocos
   

   Code Block
   data class Customer(val name: String, val email: String)

   
   

3. Use the fact that `return` and `throw` have type `Nothing`, https://kotlinlang.org/docs/reference/idioms.

1. html#todo-

1. marking-

1. code-

1. as-

1. incomplete

   Code Block

1. val x =

1. foo() ?: return notFound() val y = if(conditionSatisfied()){ 1.0 } else { error("Condition is not satisfied"}//throws inside, the type is Nothing }

   https://kotlinlang.org/docs/reference/idioms.

1. html#return-on-when-statement

   Code Block
   fun transform(color: String): Int { return when (

1. color) { "Red" -> 0

1. "Green" ->

1. 1

1. "Blue" ->

1. 2

1. else -> throw IllegalArgumentException("Invalid color param value") } }

   
   

2. Nullable truth.

   Code Block
   a?.b == true //instead of a?.

1. b ?: false

   
   

2. var x: String?; x = x ?: "Hello"; (analog for dart ?=)

   Code Block
   var x: String? = null x = x ?: "Hello"

   
   

3. Safe chain and elvis (https://kotlinlang.org/docs/reference/idioms.

1. html#if-not-

1. null-

1. and-

1. else-

1. shorthand)
   

   Code Block

1. val files = File("Test").listFiles() println(files?.size ?: "empty")

   
   

2. https://kotlinlang.org/docs/reference/idioms.

1. html#execute-if-not-null

   Code Block

1. val

1. value

1. =

1. ...

1. value?.let { ...

1. // execute

1. this

1. block

1. if

1. not

1. null }

   
   

2. https://kotlinlang.org/docs/reference/idioms.html#extension-functions

   Code Block
   fun String.spaceToCamelCase() { ... }

1. "Convert this to camelcase".spaceToCamelCase()

   
   

2. Extension properties

   Code Block
   import java.util.Calendar var Calendar.year get() = get(Calendar.YEAR) set(value) = set(Calendar.YEAR, value) val calendar = Calendar.getInstance() println(calendar.year) // 2020 calendar.year = 2021 println(calendar.year) // 2021

   
   

3. Using with/let/run to create a scope
4. Using apply/also to add a finalizing action
   https://kotlinlang.org/docs/reference/idioms.html#configuring-properties-of-an-object-apply

5.  https://kotlinlang.org/docs/reference/idioms.html#read-only-list

   Code Block
   val list = listOf("a", "b", "c")

   
   

6. Simple empty collection

   Code Block
   fun doSomething(additionalArguments: List<String> = emptyList())

   
   

7. https://kotlinlang.org/docs/reference/idioms.html#accessing-a-map

   Code Block
   println(map["key"]) map["key"] = value

   
   

8. Destructuring declaration (https://kotlinlang.org/docs/reference/idioms.

1. html#traversing-a-maplist-of-pairs)
   

   Code Block

1. for ((k, v) in map) {

1. println("$k -> $v") } val (a,b) = Pair(1, 2)

   
   

2. Public var with a private/protected setter

   Code Block
   var a: Int = 2 protected set // accessible only in descendents

   Mutable private - read-only public collections.

   Code Block
   ptivate val _list = ArrayList<Int>() val list: List<Int> get() = _list

   
   

3. https://kotlinlang.org/docs/reference/idioms.

1. html#checking-

1. element-

1. presence-

1. in-

1. a-

1. collection

   Code Block

1. if ("

1. john@example.com" in emailsList) { ... } if ("jane@example.com" !in emailsList) { ... }

   
   

2. ranges instead of for loops (https://kotlinlang.org/docs/reference/idioms.

1. html#using-ranges):

   Code Block

1. for (i in 1..100) { ... } // closed range: includes 100

1. for (i in 1 until 100) { ... } // half-open range: does not include 100 for (x in 2..10 step 2) { ... } for (x in 10 downTo 1) { ...

1. } if (x in 1..10) { ... }

   
   

2. Trailing lambdas (place lambda the last in the function parameters list, try to provide default values for parameters). Try to make such functions inline (to remove lambda creating overhead).
   

   Code Block
   fun

1. integrate(

1. from:

1. Double

1. = 0.0, to: Double = 1.0, function: (Double)→Double): Double {...} integrate{x→x*x + 2*x + 1} integrate(0.0, Pi){ sin(it) }

   
   

2. .filter.map.reduce (collection processing, higher order functions) (https://kotlinlang.org/docs/reference/idioms.html#filtering-a-list)
   

   Code Block
   val list: List<Int> = listOf(1,2,3,4,5,6) val result = list .filter{it%2 == 0} //select even numbers .map{it*it} // get square of each element .sumByDouble{it.toDouble()} //use one of reduce operations

   
   

3. Assignment to `if`/`when`/`try`

   Code Block
   val a = if(b>0) 0 else 1

   https://kotlinlang.org/docs/reference/idioms.html#trycatch-expression

   Code Block
   fun test() { val result = try { count() } catch (e: ArithmeticException) { throw IllegalStateException(e) } // Working with result }

   
   

   Code Block
   val ioResult: IOResult? = try{ readFromFile() //assign result if it read is successful } catch(t: FileNotFoundException){ null // return null if file not found }

   
   

4. https://kotlinlang.org/docs/reference/idioms.html#builder-style-usage-of-methods-that-return-unit
   
   
   

   Code Block
   fun arrayOfMinusOnes(size: Int): IntArray { return IntArray(size).apply { fill(-1) } }

1. 
   

2. Scoped use of objects (https://kotlinlang.org/docs/reference/idioms.html#java-7s-try-with-resources)

   Code Block
   val stream = Files.newInputStream(Paths.get("/some/file.txt")) stream.buffered().reader().use { reader -> println(reader.readText()) }

   
   

3. Companion object. Use companion object as an ID

4. Factory method instead of constructors

   Code Block
   class Doubles(val list: DoubleArray) @Suppress("FunctionName") fun Doubles(vararg numbers: Number) = Doubles(numbers.map{it.toDouble()}.toDoubleArray()) Doubles(1,2,3)

   
   

5. Lazy properties https://kotlinlang.org/docs/reference/idioms.html#lazy-property
   
   

   Code Block
   val p: String by lazy { // compute the string }

   
   

6. https://kotlinlang.org/docs/reference/idioms.html#convenient-form-for-a-generic-function-that-requires-the-generic-type-information
   
   

   Code Block
   // public final class Gson { // ... // public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException { // ... inline fun <reified T: Any> Gson.fromJson(json: JsonElement): T = this.fromJson(json, T::class.java)

   
   

   Non-local return

   Code Block
   fun foo() { listOf(1, 2, 3, 4, 5).forEach { if (it == 3) return // non-local return directly to the caller of foo() print(it) } println("this point is unreachable"

1. )

1. }

1. DoubleArray vs Array<Double> vs List<Double>

Unsorted

• Read line

val map: MutableMap<String, Int>
val (a, b) = readlLine()?.split(" ") ?: error("No line to read") // read line and split it by given delimeter and use destructuring declaration
map[a] = b.toInt() // Convert the value on-flight and assign it

• Use JMH for benchmarking