withTimeout

val cardStats = mutableMapOf<String, Int>()

Once the card is created in other map for example: "France" to "Paris", this is automatically created:

cardStats = mutableMapOf("France" to 0)

In the guessing function, if they miss it adds up fail attempts into the card:

cardStats[ansDef] += 1

But I get this:

Operator call corresponds to a dot-qualified call 'cardStats[ansDef].plusAssign(1)' which is not allowed on a nullable receiver 'cardStats[ansDef]'.

find {}.let {}

class Rectangle {
    val width: Int
    val length: Int

    constructor(_width: Int, _length: Int) {
        width = _width
        length = _length
    }
}

val rectangle = Rectangle()

class Rectangle {
    val width: Int
    val length: Int

    constructor(width: Int, length: Int) {
        width = width
        length = length
    }
}

class Rectangle {
    val width: Int
    val length: Int
    
    constructor(_width: Int, _length: Int) {
        width = _width
        length = _length
    }

    constructor(_sizeA: Int, _sizeB: Int) {
        width = _sizeA
        length = _sizeB
    }
}

class Rectangle {
    val width: Int
    val length: Int

    constructor(width: Int, length: Int) {
        
    }
}

class Rectangle {
    val width: Int = 1
    val length: Int = 1

    constructor(width: Int, length: Int) {
        this.width = width
        this.length = length
    }
}

class Rectangle() {
    var width: Int = 1
    var length: Int = 1

    constructor(width: Int, length: Int) {
        this.width = width
        this.length = length
    }
}

data class CarDTO(
    val make: String,
    val model: String,
    val year: Int
)

data class Car(
    val make: String,
    val model: String,
    val year: Int
) {
    constructor(carDTO: CarDTO) : this(
        make = carDTO.make,
        model = carDTO.model,
        year = carDTO.year
    )
}

data class CarDTO(
    val make: String,
    val model: String,
    val year: Int
) {
    fun toCar(): Car {
        return Car(
            make = this.make,
            model = this.model,
            year = this.year
        )
    }
}

data class Car(
    val make: String,
    val model: String,
    val year: Int
)

@PostMapping("/")
fun addAnnouncement(@RequestBody dto: AnnouncementDTO) {
    println(dto);
    manager.addAnnouncement(dto.toAnnouncement())
}

{
  "text": "Hello",
  "occupant": "35A",
  "date": "2020-10-09"
}

gradle/*

val employeeRunData = EmployeeRunData(annualSalary = BigDecimal(120000))

val employeeRunData = EmployeeRunData(annualSalary = 120000))

class ControlledMap(type: Type, index: Int) {
    private val table = mapOf(type to index)

    fun get(type: Type): Int =
        table.getOrElse(type) { throw IllegalArgumentException("Trying to get a non existing content from ControlledMap") }

    operator fun plus(other: ControlledMap): ControlledMap {
        if (table.keys.any { other.table.containsKey(it) }) {
            throw IllegalArgumentException("Cannot merge ControlledMaps with clashing keys")
        }


        // want to return a new ControlledMap where table is the union of the 2 tables (this.table + other.table)
    }


    enum class Type {
        A,
        B,
        C,
        D
    }
}

val numbers = listOf(1,2,4,8,11,14)

val differencesTwoIndexesApart = listOf(3,6,7,6)

@Test
    fun reproducibleNPE() {
        ZoneId.of("Europe/Berlin").rules.getTransition(LocalDateTime.MIN).isOverlap
    }

fun <T> listDiff(original: List<T>, revised: List<T>): List<DiffOp<T>>

sealed class DiffOp<T> {
  class Add<T>(val element: T, val index: Int) : DiffOp<T>()
  class Remove<T>(val element: T, val index: Int) : DiffOp<T>()
}

val myMap = sortedMapOf<String, Collection<Int>>()

first.intersect(second.toList()).toIntArray()

private fun intersection(a: IntArray, b: IntArray): IntArray {
        val c = IntArray(min(a.size, b.size))
        if (c.isEmpty()) {
            return c
        }
        var i = 0
        var j = 0
        var k = 0
        while (i < a.size && j < b.size) {
            val aa = a[i]
            val bb = b[j]
            val comparison = aa - bb
            if (comparison == 0) {
                c[k++] = aa
                i++
                j++
            } else if (comparison < 0) {
                i++
            } else {
                j++
            }
        }
        return c.copyOf(k)
    }

fun aFun() : ObjectA?{
val (side,line) = when(someData){
      is TypeA -> thread.position?.let { diffData.linesMapper.findFileLocation(it) } ?: return null
      is TypeB -> ... ?: return null
}

return ObjectA(side,line)

data class City (
    val name : String = "",
    val country : String = "",
    val population : Int = 0,
)

val cities = { listOf(
    City("a", "1", 1305770),
    City("b", "1", 556934),
    City("c", "2", 1924701),
    City("d", "3", 5785861),
    City("e", "3", 4467118),
) }

mylist.zip(mylist.drop(1)) { a, b -> myfunction(a,b) }

zip(mylist, mylist.drop(1), mylist.drop(2)) { a, b, c -> myfunction(a,b,c) }

List

List.plus

fun fn1(x: Int): Boolean = x % 2 == 0
fun fn2(x: Int): Boolean { return x % 2 == 0 }

fun main () {
    val listNum = listOf(1, 2, 3, 4, 5, 6)
    val fn3: (Int) -> Boolean = { it % 2 == 0 }

    println(listNum.filter(::fn1)) // compiles and outputs [2, 4, 6]
    println(listNum.filter(::fn2)) // compiles and outputs [2, 4, 6]
    println(listNum.filter(fn3)) // compiles and outputs [2, 4, 6]

    // e: org.jetbrains.kotlin.util.KotlinFrontEndException: Exception while analyzing expression at (17,13)
    println(listNum.filter(::fn3)) // Error
}

.not()

!

data class Foo(val id: Int? = null, val someStringProperty: String? = null)

createFoo(propertyName: String, propertyValue: Any): Foo

val foo1 = createFoo("id", 5) // Foo(id = 5, someStringProperty = null)
val foo2 = createFoo("someStringProperty", "someString") // Foo(id = null, someStringProperty= "someString")