Iterator

Sequence

Sequence

Map<K, V>.putAllWith(other: Map<K, V>, remappingFunction: (V, V) -> V): Map<K,V>

public interface ResourceManager<R extends NodeReadOnlyTrx & NodeCursor, W extends NodeTrx & NodeCursor>

lateinit var func: () -> Unit

// <https://mvnrepository.com/artifact/io.ktor/ktor-client-features>
compile group: 'io.ktor', name: 'ktor-client-features', version: '1.3.0'
// <https://mvnrepository.com/artifact/io.ktor/ktor-client-json>
compile group: 'io.ktor', name: 'ktor-client-json', version: '1.3.0'
// <https://mvnrepository.com/artifact/io.ktor/ktor-client-apache>
compile group: 'io.ktor', name: 'ktor-client-apache', version: '1.3.1'

\u1f1e9\u1f1ea

java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 6

fun getMarketMap(stats: MarketStats): Map<String,MarketResponse> {
        var map = mutableMapOf<String,MarketResponse>()
        for(i in 0 until (stats.marketPrice.size)) {
            println("$i th: ${locations[i]}")
            map[locations[i]] = stats.marketPrice[i]
        }
        return map
    }

There's a cycle in the delegation calls chain

internal class EmptyComponentModel private constructor(
    override val countryCode: CountryCode,
    override val saleStatus: SaleStatus,
    override val price: Monetary? = null,
    override val saleNotes: String? = null
) : PlacardComponentModel(ListingSaleType.Unknown) {

    constructor(countryCode: CountryCode, saleStatus: SaleStatus) : this(
        countryCode = countryCode,
        saleStatus = saleStatus
    )
}

class A {
    var x: Int = 0
    var y: Int = 0
    constructor(x: Int) {
        this.x = x
    }
    constructor(x: Int, y: Int) {
        this(x + y)
        this.y = y
    }
}

null

removeIf((E) -> Boolean)

removeAll((E)->Boolean)

api.fetchEntry(entry)

Future<String>

for(indexPage in api.fetchIndexIterable()) {
	for(entry in indexPage) {
		val document = api.fetchEntry(entry)
		val changed = computeSomeChanges(document)
		writeInOrder(changed)
	}		
}

async {}

.awaitAll()

map { async { api.fetchEntry(it) } }.awaitAll()

data class Flow(
    val ids: List<MyId>,
    val steps: MySteps
) {

    constructor(ids: List<MyId>) : this(
        ids,
        MySteps(ids.toSteps(), ids.toSteps().first())
    )
}

data class MySteps(val steps: List<MyStep>, val currentStep: MyStep)

ids

ds.toSteps().first()

vararg args: Any

String

IllegalFormatConversionException

logDebug("WindowRef %08X", ref.id) // ref.id is an Int

fun logDebug(fmt: String, vararg args: Any) {

   val toAppend = fmt.format(args) // IllegalFormatConversionException
   ...
}

Error:(2, 44) Kotlin: Type parameter T is declared as 'in' but occurs in 'invariant' position in type SomeClass<String, T>

in

abstract class A<T>

someMethod(item: SomeClass<String, T>)

T

in

abstract class A<in T> {
    fun someMethod(item: SomeClass<String, T>) {
        println(item)
    }
}

open class SomeClass<K,V>(
    override val entries: Set<Map.Entry<K, V>>,
    override val keys: Set<K>,
    override val size: Int,
    override val values: Collection<V>
) : Map<K,V>{
    override fun containsKey(key: K): Boolean {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun containsValue(value: V): Boolean {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun get(key: K): V? {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun isEmpty(): Boolean {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}