Collections.unmodifiableList

listOf

unmodifiableList

interface Importer {

fun run(value: String): String

}

val x = listOf(

Importer { it.replace("h", "o")}

)

Plugin org.jetbrains.kotlin:kotlin-maven-plugin:1.4 or one of its dependencies could not be resolved: Failure to find org.jetbrains.kotlin:kotlin-maven-plugin:jar:1.4

AutoCloseable.use(...)

class OnlyAudioRecorder public constructor(val hadoopAddr: String, val kafkaAddr: String ){
 companion object{
  val instance:OnlyAudioRecorder by lazy (mode = LazyThreadSafetyMode.SYNCHRONIZED){
            OnlyAudioRecorder(hadoopAddr, kafkaAddr)
        }
    }
// why this hadoopAddr and kafkaAddr are not referenced?

abstract class AbstractResourceTopic(val state: ResourceState? = null, val isOn: Boolean? = null) {
    abstract val resourceType: ResourceType
}

fun AbstractResourceTopic.getIcon(): Int {
    this.state?.let {
        return when (it.state) {
            0 -> getStateZeroIcon()
            1 -> getStateOneIcon()
            2 -> getStateTwoIcon()
            else  -> getStateZeroIcon()
        }
    }
    this.isOn?.let {
        return if (isOn) getOnIcon() else getOffIcon()
    }
    return getStateZeroIcon()
}

abstract class AbstractResourceTopic {
    constructor(state: ResourceState)
    constructor(isOn: Boolean)
    abstract val resourceType: ResourceType
}

fun AbstractResourceTopic.getStateIcon(): Int {
        return when (it.state) {
            0 -> getStateZeroIcon()
            1 -> getStateOneIcon()
            2 -> getStateTwoIcon()
            else  -> getStateZeroIcon()
        }
    }
}
fun AbstractResourceTopic.getIsOnIcon(): Int {
    return if (isOn) getOnIcon() else getO
}

vararg

inline class

!!

val extractor = when {
            config.contains(REGEX) && config.contains(FORMAT)  -> FormatAndRegexExtractor(config[REGEX]!!, config[FORMAT]!!)
            config.contains(REGEX) && !config.contains(FORMAT) -> NamedCaptureGroupExtractor(config[REGEX]!!)
            config.contains(DELIMS) && config.contains(FIELDS) -> DelimiterExtractor(config[DELIMS]!!, config[FIELDS]!!)
            else                                               -> throw IllegalArgumentException("can not process this configuration: $config")
        }

null

fun <T> aFunctionWithOptionalParam(
    optionalParam: T? = null
) {
    if (/* optionalParam is set*/) {
        someCallbackIfSet()
    }
}

fun whatIWant() {
    aFunctionWithOptionalParam(1) // callback is invoked
    aFunctionWithOptionalParam(null) // callback is invoked
    aFunctionWithOptionalParam() // callback should not be invoked
}

val instance:OnlyAudioRecorder by lazy (mode = LazyThreadSafetyMode.SYNCHRONIZED){
         OnlyAudioRecorder(h,k)}
// what does by lazy (mode = ...) { ... } mean?  should lazy take a lambda? but (...) {...} is not a lambda

//Consider the code snippet below. What will it print?

var num = 0
println(num++ + ++num)

num++ + ++num     (num = 0)
num++ + 1         (num = 1)
1 + 1             (num = 1)

<http://java.io|java.io>.InputStream

InputStream

interface Test {
    val a: String
}

var Test.b: String
    get() = field
    set(value) = field = value

fun

class D

class C

fun interface A {
    fun f()
}

fun interface B {
    fun f()
}

class C(b: B) : A by A(b::f) //works

class D(b: B) : A by { b.f() } //doesn't work

exitProcess(0)