toString

interface IS<T> {fun <T>T.fmap():T}
sealed class IIS<T>: IS<T>
data class IntIS<Int>(val x:Int): IIS<Int>(){
    fun Int.fmap(){
        return x+1
    }
}

kotlinc -version

kotlinc-jvm 1.4-M2

Gson().fromJson(json, MyDataClass::class.java)

inline fun <reified T> Gson.fromJson(json: String): T = this.fromJson(json, T::class.java)

Gson().fromJson<MyDataClass>(json)

sourceSets.main {
    withConvention(org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet::class) {
        // Put components and bases here (src)
        kotlin.srcDirs(
                "kotlin/bases/cli/src",
                "kotlin/components/file/src",
                "kotlin/components/srcreader/src"
        )
    }
}

someComputationUsingA(a)

FooSubType

class FooSubType(
    val a: Int,
    val b: String
): FizzSuperType(
    someComputationUsingA(a) + " $b"
)

FooSubType

fun main() {
    val sender = Sender(GlobalScope.coroutineContext)
    GlobalScope.launch {
        sender.send("Message1") // this is processed
        sender.send("Message2") // this is not processed anymore :(
    }
    Thread.sleep(2000)
}

class Sender(
    coroutineContext: CoroutineContext
) {

    private val channel = Channel<String>(32768)
    private val supervisor = SupervisorJob(coroutineContext[Job])
    private val scope = CoroutineScope(coroutineContext + supervisor)

    init {

        val handler = CoroutineExceptionHandler { _, e ->
            println(e.message)
        }

        with(scope) {
            launch(handler) {
                MyProcessor(channel).run() // <--- how can we restart/recreate it when exception is thrown?
            }
        }
    }

    suspend fun send(message: String) {
        channel.send(message)
    }
}

class MyProcessor(
    private val channel: Channel<String>
) {

    suspend fun run() {
        for (message in channel) {
            process(message)
        }
    }

    private suspend fun process(message: String) {
        // something that occasionally throws Exception
        println("Processing $message")
        throw RuntimeException("Failed to process $message")
    }
}

/**
     * Given a collection of integers and a target integer (target),
     * find all unique combinations of integers where the sums of the combinations equal the target.
     * @param integers The integers used in the combinations
     * @param target The target sum
     * @return List<List<Int>> which represents all the possible combinations of integers that sum up to the target
     */
    private fun combinationSumII(integers: IntArray, target: Int, limit: Int): List<List<Int>> {
        fun backtrack(
            integers: IntArray,
            target: Int,
            limit: Int,
            index: Int,
            trace: List<Int>,
            allCombinations: MutableList<List<Int>>
        ) {
            for (i in index until integers.size) {
                val current = integers[i]
                if (i > index && current == integers[i - 1]) continue
                if (trace.size >= limit) break

                val remainingValue = target - current
                when {
                    (remainingValue == 0) -> {
                        val set = ArrayList<Int>(trace)
                        set.add(current)
                        allCombinations.add(set)
                    }
                    (remainingValue > 0) -> {
                        val newTrace = ArrayList<Int>(trace)
                        newTrace.add(current)
                        backtrack(integers, remainingValue, limit, i + 1, newTrace, allCombinations)
                    }
                }
            }
        }

        val allCombinations = mutableListOf<List<Int>>()
        val result = mutableListOf<Int>()
        integers.sort()
        backtrack(
            integers = integers,
            target = target,
            limit = limit,
            index = 0,
            trace = result,
            allCombinations = allCombinations
        )
        return allCombinations
    }

val integers = 43..166.toList().toIntArray()
val target = 600
val limit = 5

val integers = (22..166).toList().toIntArray()
val target = 554
val limit = 5

val

init

init

if (myVar != null) { ...

Unnecessary safe call on a non-null receiver

null

infix fun A.function(b): X

operator fun X.invoke(f: () -> Unit)

a function b { ... }

plus

a function b +{ ... }

infix operator fun X.invoke(f: () -> Unit)

a function b invoke { ... }

invoke

(a function b) { ... }

Map<ContactDetailsType, ContactDetails>

val email =  source.customer.customerEmail?.let { Customer.ContactDetailsType.EMAIL to Customer.EmailAddress(it)}
val phone = source.customer.telephone?.let { Customer.ContactDetailsType.GENERAL_PHONE to it.toPhoneNumber() }
val mobile = source.cardholderInfo?.mobilePhone?.let { Customer.ContactDetailsType.MOBILE to it.toPhoneNumber()}
val landLine = source.cardholderInfo?.homePhone?.let { Customer.ContactDetailsType.MOBILE to it.toPhoneNumber()}

val contactDetails: Map<Customer.ContactDetailsType, Customer.ContactDetails> = listOf(email, phone, mobile, landLine).filterNotNull().toMap()

copy

val moduleCache : java.util.Map<ModuleInfo, WeakReference<ModuleInfo>> = Collections.synchronizedMap(WeakHashMap<ModuleInfo, WeakReference<ModuleInfo>>())

[TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH] Type inference failed. Expected type mismatch: 
required:
java.util.Map<ModuleInfo, WeakReference<ModuleInfo>>
found:
(MutableMap<ModuleInfo!, WeakReference<ModuleInfo>!>..kotlin.collections.Map<ModuleInfo!, WeakReference<ModuleInfo>!>?)

enum ThatEnum(val thatProperty: Float) {
    FirstEntry(thatProperty = 10),
    AnotherEntry(thatProperty = 20),
    LastEntry(thatProperty = Float.POSITIVE_INFINITY);

    companion object {
        init {
            check(values().contentEquals(values().apply { sortBy { it.thatProperty } }))
        }
    }
}

companion object

Caused by: org.jetbrains.org.objectweb.asm.tree.analysis.AnalyzerException: Argument 2: expected R, but found I

var countryList= mutableSetOf<String>()

var us= mutableSetOf<String>()
var in= mutableSetOf<String>()
var br= mutableSetOf<String>()

SuspendCloseable

close()

val flow1 = flow<Int> {
    emit(1)
}
val flow2 = flow<Int> {
    throw IOException()
}
merge(flow1, flow2).onEach {
    print(it.toString() + "\n")
}.catch {
    emit(3)
}.launchIn(CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>))