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.html#creating-a-singleton

   Code Block
   object Resource { val name = "Name" }

   
   

7. https://kotlinlang.org/docs/reference/idioms.html#instance-checks

   Code Block
   when (x) { is Foo -> ... is Bar -> ... else -> ... }

   
   

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

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

   
   

9. Use the fact that `return` and `throw` have type `Nothing`, https://kotlinlang.org/docs/reference/idioms.html#todo-marking-code-as-incomplete

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

   
   

10. Nullable truth.

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

    
    

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

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

    
    

12. Safe chain and elvis (https://kotlinlang.org/docs/reference/idioms.html#if-not-null-and-else-shorthand)
    

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

    
    

13. https://kotlinlang.org/docs/reference/idioms.html#execute-if-not-null

    Code Block
    val value = ... value?.let { ... // execute this block if not null }

    
    

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

    Code Block
    fun String.spaceToCamelCase() { ... } "Convert this to camelcase".spaceToCamelCase()

    
    

15. 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

    
    

16.  With block

Unsorted

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

1. html#configuring-

1. properties-

1. of-

1. an-

1. object-

1. apply

   Code Block

1. val myRectangle = Rectangle(

1. ).apply { length = 4 breadth = 5 color = 0xFAFAFA }

   
   

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

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

   
   

3. Simple empty collection

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

   
   

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

1. html#checking-element-

1. presence-

1. in-

1. a-

1. collection

   Code Block

1. if (

1. "john@example.com" in

1. emailsList) {

1. ... } if

1. ("jane@example.com"

1. !in emailsList) { ... }

   
   

2. ranges instead of for loops (https://kotlinlang.org/docs/reference/idioms.html#using-ranges):

   Code Block
   for (i in 1..100) { ... } // closed range: includes 100 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) { ... } if (x in 1..10) { ... }

   
   

3. 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 integrate(from: Double = 0.0, to: Double = 1.0, function: (Double)→Double): Double {...} integrate{x→x*x + 2*x + 1} integrate(0.0, Pi){ sin(it) }

   
   

4. .filter.map.reduce (collection processing, higher order functions) (https://kotlinlang.org/docs/reference/idioms.

1. html#filtering-

1. a-list)
   

   Code Block
   val list: List<Int> = listOf(

1. 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

   
   

   
   

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

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

   
   

3. Destructuring declaration (https://kotlinlang.org/docs/reference/idioms.html#traversing-a-maplist-of-pairs)
   

   Code Block
   for ((k, v) in map) { println("$k -> $v") } val (a,b) = Pair(1, 2)

   
   

Unsorted

• Companion object

• https://kotlinlang.org/docs/reference/idioms.html#lazy-property

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

• https://kotlinlang.org/docs/reference/idioms.html#return-on-when-statement

fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

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

fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // Working with result
}

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

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

• https://kotlinlang.org/docs/reference/idioms.html#configuring-properties-of-an-object-apply

val myRectangle = Rectangle().apply {
    length = 4
    breadth = 5
    color = 0xFAFAFA
}

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

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

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

//  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

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

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

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

• Factory method instead of constructors

class Doubles(val list: DoubleArray)

@Suppress("FunctionName")
fun Doubles(vararg numbers: Number) = Doubles(numbers.map{it.toDouble()}.toDoubleArray())

Doubles(1,2,3)

• Public var with a private/protected setter
  

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

• Mutable private - read-only public collections.
  

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

• 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).
  

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

• Assignment to `if`/`when`/`try`
  

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

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

• 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

• Simple empty collection

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