typealias SourceOrFactory<T> = List<T> | DataSource.Factory<T>

=

-

class Foo {
    companion object
}

typealias Bar = Foo

fun Foo.Companion.hoge() = "hoge" // Okay
fun Bar.Companion.qux() = "qux" // ERROR: Unresolved reference: Companion

mylist + newElement

data class Test(val test1: Int, val test2: Int, private val test3: Int = test2 * test1)

map[key]?.let { f(it) } ?: init

fromPriceValueET.typeface = Typeface.createFromAsset(
            assets, "fonts/Sofia Pro Bold.otf"
        )

        toPriceValueET.typeface = Typeface.createFromAsset(
            assets, "fonts/Sofia Pro Bold.otf"
        )

        budgetCurrencyTV.typeface = Typeface.createFromAsset(
            assets, "fonts/Sofia Pro Bold.otf"
        )

fun diskIO(): Executor = diskIO

    fun diskIO(): Executor {
        return diskIO
    }

Observable

If the constructor has annotations or visibility modifiers, the constructor keyword is required

@Singleton
open class AppExecutors(
    private val diskIO: Executor,
    private val networkIO: Executor,
    private val mainThread: Executor
) {

If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either directly or indirectly through another secondary constructor(s). Delegation to another constructor of the same class is done using the this keyword:

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

parent.children.add(this)

val instance by lazy { SomeClass() }

class Test (
    val id: UUID
) {
	private constructor(builder: Builder) : this(builder.id)
	companion object {
		inline fun build(id: UUID, block: Builder.() -> Unit)  = Builder(id). apply(block).build()
	}
	class Builder(
		val id: UUID) {
        var text: String? = null
        fun build() = Test(this)
    }
}

apply

Unresolved reference: apply