given two nullable lists,

a: List<String>?

and

b:List<String>?

if any are not null, return a concat list

else return null

b?.let { a?.plus(it) ?: it } ?: a

?: it

Error:(13, 30) Kotlin: Type checking has run into a recursive problem. Easiest workaround: specify types of your declarations explicitly

package ro.jtonic.tutorials.kt.oop.miscs

private const val PI = Math.PI
const val E = Math.E

private fun computePi() = PI
fun computeE() = E

class MyMath {

    val E = FilePrivateUtils@::E.get() // here is the compilation error
    val pi = FilePrivateUtils@::PI.get()

    fun computingPi() = FilePrivateUtils@::computePi.invoke()
    fun computingE() = FilePrivateUtils@::computeE.invoke()
}

data class Foo(var s: Int? = null)

@JvmOverloads

DefaultConstructorMarker

x?.let { bla(it) }

let(x, Bla::bla)

when

for

data class ResultWrapper<out T>(val request: RequestInfo, val obs: T, val typeOfResult : KClass<*>? = null)

when

typeOfResult

when (item.typeOfResult) {
             is Enemy -> {
                  messages.add("Received instance of type ${item.typeOfResult.simpleName} !")
              }

val byteVal:Byte = 0
val isZero = byteVal == 0

val byteVal:Byte = 0
val isZero = byteVal == 0.toByte()

toByte()

L

f

class Example {

    private val backingMap = mutableMapOf<String, MutableSet<String>>()

    fun addVertex(v: String): Boolean = backingMap.putIfAbsent(v, mutableSetOf()) == null
    
    fun addEdge(v: String, w: String): Boolean {
        listOf(v, w).map(::addVertex)
        return backingMap[v]!!.add(w)
    }

}

fun <ACTUAL> expect(
  actual: ACTUAL,
  block: ObjectAssert<ACTUAL>.(ACTUAL) -> Unit
): ObjectAssert<ACTUAL>

fun <ELEMENT> expect(
  actual: List<ELEMENT>,
  block: SoftAssertionListAssert<ELEMENT>.(List<ELEMENT>) -> Unit
): SoftAssertionListAssert<ELEMENT>

fun <ACTUAL> expect(actual: ACTUAL): AbstractObjectAssert<*, ACTUAL>

fun <ELEMENT> expect(actual: List<ELEMENT>): ListAssert<ELEMENT>

map

listOf("1", "2", "3").map { it.toInt() }
listOf("1", "2", "3").map(String::toInt)

\n

str.split("\n").map { it.split("\t").map { it.toInt() } }

public

internal

package-private