*.kt

.kt

Regex

Pattern

ByteArray

fun mapBytesToList(arr: ByteArray): List<T> {
  if (arr.isEmpty()) {
    return emptyList()
  }
  val bais = ByteArrayInputStream(arr)
  var ois: ObjectInputStream? = null
  return try {
    ois = ObjectInputStream(bais)
    ois.readObject() as List<T>
  } catch (e: Exception) {
    emptyList()
  } finally {
    try {
      ois?.close()
    } catch (e: Throwable) {
    }
  }
}

UNCHECKED_CAST

ois.readObject() as List<T>

FAILURE: Build failed with an exception.

* Where:
Build file '/Users/xxxx/Develop/kotlin/kotlin-native/build.gradle' line: 66

* What went wrong:
A problem occurred evaluating project ':kotlin-native'.
> Incorrect Xcode version: 13.1. Required major Xcode version is 12.

fun main() {
    val callback = { i: Int, j: Int ->
        val ii = i.times(j)
        val jj = j.times(ii)
        ii + jj
    }

    println(addAndMultiply(5, 6) { i, j ->
        i + 1 + j
    })

    println(addAndMultiply(5, 6, callback))
}

inline fun <T> addAndMultiply(x: T, y: T, call: (T, T) -> T): T where T : Number {
    if (x is BigDecimal || x is BigInteger) return call(x, y)
    if (y is BigDecimal || y is BigInteger) return call(x, y)

    return call(x, y) * x * y
}

return call(x, y) * x * y

org.jetbrains.kotlin.backend.common.BackendException: Backend Internal error: Exception during IR lowering

val Extension.dispatcher by lazy {
    SomeDispatcher()
}

dispatcher

val deepList = listOf(
    listOf(
        listOf(-1, 0),
        listOf(1)
    ),
    listOf(2, 3),
    listOf(4, 5, 6)
)
println(deepList.flatten()) // [-1, 0, 1, 2, 3, 4, 5, 6]

val deepList = listOf(
    -1,
    listOf(listOf(listOf(0))),
    listOf(2, 3),
    listOf(4, 5, 6)
)
println(deepList.flatten()) // [-1, 0, 1, 2, 3, 4, 5, 6]

ByteArray

byteArrayOf

ubyteArrayOf

it - 128

with

Unit

public inline fun <T> with(receiver: T, block: T.() -> Unit): Unit {
    receiver.block()
}

fun process(data: Data) = with(data) {
    ///doSomething
    Unit
}

fun doSomething(param: SomeParams): Single<Something>

fun doSomething(param: SomeParams): Single<Something> = Single.just(
   runBlocking {
        doSomething()
    }
)
suspend fun doSomething(): Something = TODO()

val rng = Random(0)
generateSequence { rng.nextInt() }.take(10).toList()

class Foo(val bar: Bar)
class Bar(val baz: String)


val foo = Foo(Bar("baz"))

// why isn't this possible?
val bazGetter = Foo::bar::baz

// whereas this is ok?
val bazGetter2: (Foo) -> String = { it.bar.baz }

@Inject

fun foo() {
    lateinit var x: Int
    if (::x.isInitialized()) {}
}

1

Scanner(myFile).findAll(myPattern)

asSequence

Stream