experimental

@Suppress("NOTHING_TO_INLINE")
internal class CoroutineScheduler(
    private val corePoolSize: Int,
    private val maxPoolSize: Int,
    private val idleWorkerKeepAliveNs: Long = IDLE_WORKER_KEEP_ALIVE_NS,
    private val schedulerName: String = DEFAULT_SCHEDULER_NAME
) : Executor, Closeable {
    init {
        require(corePoolSize >= MIN_SUPPORTED_POOL_SIZE) {
            "Core pool size $corePoolSize should be at least $MIN_SUPPORTED_POOL_SIZE"
        }
        require(maxPoolSize >= corePoolSize) {
            "Max pool size $maxPoolSize should be greater than or equals to core pool size $corePoolSize"
        }

@kotlin.internal.InlineOnly
public inline fun require(value: Boolean, lazyMessage: () -> Any): Unit {
    contract {
        returns() implies value
    }

@ContractsDsl
@ExperimentalContracts
@InlineOnly
@SinceKotlin("1.3")
@Suppress("UNUSED_PARAMETER")
public inline fun contract(builder: ContractBuilder.() -> Unit) { }

fun foo(bar: String) {
	val baseUrl = "https://${bar}com/whatever"
	doFoo(baseUrl)
}

compile

kotlin-stdlib

var t = 1

var tRef: Int
    get() = t
    set(value) {
        t = value
    }

tRef

fun checkCust(accNo:Int):Int {
    for (x in 0 until 10) {


        return if (dataBase[x]?.accNo == accNo) {
            x
        } else {
            -1
        } 
    }

 }

error: unsupported [literal prefixes and suffixes]

val fishnet="Net"to"Catch fish"

val fishnet="Net" to "Catch fish"

to

fun pairGame():Pair<String,String,Int>
{
    return ("Hi" to "Bye" to 5)
}
println(" ${pairGame().third}")

error: 2 type arguments expected for class Pair<out A, out B>

fun pairGame():Pair<String,String,Int>

Function

import java.util.function.Function

listOf(1, 2, 3).stream().map(Function<Int, Int> { it * it })
listOf(1, 2, 3).stream().map { it * it }

fun takesSAM(x: Int, f: Function<Int, Int>): Int = f.apply(x)

takesSAM(5, Function { it * it })
takesSAM(5) { it * it } // compiler error

var allBooks= listOf<String>("Romio & Juliet","Hamlet","The tempest","macabeth")
var library= mapOf<>("Shakespeare" to allBooks[0],"Shakespeare" to allBooks[2])
val value:Boolean=allBooks.any{it.contains("Hamlet")}
println("${value}")

incomplete code