package toto.toto2

@ExperimentalUnsignedTypes
fun UByteArray.toUnsignedInt(): UInt {
    return ...
}

object

myUInt = myUByteArray.toUnsignedInt()

class MembershipInfo {
    var birthday: String? = null
        get() = if (field.isNullOrBlank() && birthdayEnc.isNotNullOrBlank()) {
            field = birthdayEnc.let {
                AesEncryptor.decryptText(it)
            }
            field
        } else {
            field
        }
    var birthdayEnc: String? = null
        get() = if (field.isNullOrBlank() && birthday.isNotNullOrBlank()) {
            field = birthday.let {
                AesEncryptor.encryptText(it)
            }
            field
        } else {
            field
        }
}

sealed class Sc {
    object Foo : Sc()
}

fun (sc: Sc){
    when (sc){
        Sc.Foo -> sc // <-- type is still Sc here, not Foo
    }
}

sealed class TimedEvent(val eventTime: Long)
data class FxRateEvent(val currency: String, val rate: Double, eventTime: Long) : TimedEvent(eventTime)

class A<T> {}

class <A?> {}

{ ... } { ... }

myPairs.associateBy { (k, _) -> k } { (_, v) -> v } // does not compile
myPairs.associateBy({ (k, _) -> k }, { (_, v) -> v }) // compiles

sequence { }

StreamingCmd

CmdBase

SequenceScope

mutableMap<String, String>

fun doSomething(param: String)
fun foo(param: String) 

foo { doSomething(it) }
vs
foo(::doSomething)
vs
foo(instance::doSomething)

require

requireNotNull

IllegalArgumentException

Map<K, List<V>>

List<Pair<K,V>>

toMap()

groupBy

fun <K, V> List<Pair<K, V>>.toMapAggregate(): Map<K, List<V>> = groupBy(
    { (k, _) -> k },
    { (_, v) -> v }
)