sealed class A {
    fun a() = apply { /* doSomething */ }
}

class B : A() {
    fun b() = apply { /* doSomething */ }
}

class C : A() {
    fun c() = apply { /* doSomething */ }
}

B().a().b() // cannot call b() now :(
C().a().c() // cannot call c() now :(

/

40.toBigDecimal() / 100.toBigDecimal()
0
40.toBigDecimal().divide(100.toBigDecimal())
0.4

/

emptyList()

ArrayList()

cache.entries.removeAll {
            val res = now - it.value.first > duration
            if (res) <http://log.info|log.info>("Removing value in cache $name for key ${it.key}")
            res
        }

list.map { process(it) }

com.github.johnrengelman.shadow

application

if (list is ObservableList<Course>)

Room

foo.if { bar() }

foo

bar()

if

data
    .filter { it.hasErrors }
    .map { it.error }
    .any { it is MyException }
    .then { /*Treat that exception*/ }

data
    .filter { it.hasErrors }
    .map { it.error }
    .takeIf { it is MyException }
    ?.let { dealWith(it) }

id

val

equals()

id

@Entity
data class Term(
        @Id
        val id: UUID,

        val name: String
) {

    val definition: Definition = Definition.DEFAULT

    constructor(id: UUID, name: String, definition: Definition) : this(id, name) {
        this.definition = definition
    }
}

typealias Prefix = String; class Form(request: Request, prefix: String) { constructor(request: Request, postfix: String) : this(request, "") }

data class Response<T>(
  ...
  val data: List<T>
}

lateinit modifier is not allowed on extension properties

data
                .mapNotNull {
                    val type = it.asJsonObjectOrNull()?.get("type")?.asStringOrNull()
                    val events = it.asJsonObjectOrNull()?.get("events")?.asJsonArrayOrNull()

                    if (type != null && events != null)
                        type to events
                    else
                        null

                }.toMap()

Array<Float>

Float[]