ByteBuffer

// this delegation works

interface A { fun foo() }
interface B { fun bar() }

class AImpl() : A { override fun foo() = println("default foo") }
class BImpl(private val a: AImpl) : B, A by a { override fun bar() = println("bar") }

// ==============

// how could I do a delegation for an inherited interface?
interface A { fun foo() }
interface B : A { fun bar() }

class AImpl() : A { override fun foo() = println("default foo") }
// no idea how to delegate
class BImpl(private val a: AImpl) : B by a { override fun bar() = println("bar") } // ?

list.sortedWith(compareBy ({
    when(it.state) {
       A -> -1
       B -> 0
       C -> 1
   }
}))

list: ["a", "b", "c", "d", "e", "f", "g"]
give specify position: 3
result: ["a", "b", "c"]

String

data class Test<T>(
    val key: String,
    val additionalData: T
)

inline fun <reified T> Test<*>.checkSafeCast(): Test<T>? {
    return if (this.additionalData is T) {
        this as Test<T> // Unchecked cast
    } else {
        null
    }
}

intervals = [[1,3],[2,6],[8,10],[15,18]]
Arrays.sort(intervals, compareBy { it[1] })

fun main() = runBlocking {
    // ... launch some stuffs
    // wait for ctrl-C, how?
    cleanup()
    cancel()
}

+

-

branchFilter {
                +"refs/heads/my-feature"
            }

object

const val

MyObjectWithConstant::class.declaredMemberProperties

data class Category(
    val id: UUID,
    var title: String,
    var slug: String,
    var subCategories: List<Category>
)

runCatching

try {} finally {}

recover{}

fun getStreetNameByStreetId(id: String): String {
        val query = Query()
        query.fields().include("name")
        query.addCriteria(Criteria.where("_id").`is`(id))
        var streetName = ""
        mongoTemplate.executeQuery(
            query, STREET_COLLECTION
        ) { document: Document ->
            streetName = document.getValue("name").toString()
        }
        return streetName
    }

addOrRemove(element, boolean)

if (boolean) set.add(element) else set.remove(element)

@DslMarker

kotlin {
  explicitApi = ExplicitApiMode.Disabled
}

Unknown value for parameter -Xexplicit-api: 'disabled'. Value should be one of {disable, strict, warning}

enum class ExplicitApiMode(private val cliOption: String) {
    Strict("strict"),
    Warning("warning"),
    Disabled("disabled"); // this should be renamed to disable and/or in another place have to check for disabled instead of disable

    fun toCompilerArg() = "-Xexplicit-api=$cliOption"
}

val classes: List<KClass<*>> = listOf(
    Person::class,
    Teacher::class,
)

val classes: List<KClass<Any>> = listOf(
    Person::class,
    Teacher::class,
)

*

Any

*

class CompassHeading(degrees: Double) {

    private var _degrees by Delegates.notNull<Double>()
    var degrees: Double
        get() = _degrees
        set(value) {
            var d = value % 360.0
            if (d < 0.0) d += 360
            _degrees = d
        }

    init {
        this.degrees = degrees
    }
}

interface Action {
//    interface DSL Builder
    operator fun<T> invoke(block: T.() -> Unit)
}