val KProperty0<*>.isInitialized: Boolean

inline class Result<out T> : Serializable

import java.lang.System.`in` as stdin
val input = Scanner(stdin)
val a = 1
val c = a + if (p) a else input.nextInt()

class SomeButtonfulActivity: Activity() {
  //KotterKnife
  val btn0: Button by bindView(R.id.main.btn_0)
  val btn1: Button by bindView(R.id.main.btn_1)
  val btn2: Button by bindView(R.id.main.btn_2)
  override fun onCreate(savedState: Bundle) {
    super.onCreate(savedState)
    //no-op ...?
    btn0.onClickListener = {_ -> toast("wtf")}
    btn1.onClickListener = {_ -> toast("wttf")}
    btn2.onClickListener = {_ -> toast("wtttf")}
  }
}

onClickListener

function fixedRateSchedule(time_ms, op) {
  op(); setTimeout(() => fixedRateSchedule(time_ms, op), time_ms);
  //也可以直接用 Function.prototype.bind
  //语义上我们创建了一个依赖它上次调用的参数(是全等)引用的 fixedRateSchedule 闭包，实际上是不是新闭包可以自己用 (===) 判断。
}

fixedRateSchedule

import java.nio.ByteOrder as NioByteOrder

typealias Cnt = Int
typealias Idx = Int
typealias IdxRange = IntRange
typealias Buffer = ByteArray

infix fun IdxRange.untilSize(size: Cnt): IdxRange = this until (this+size) //0 until (0+10): 0..9
inline val IdxRange.size: Cnt get() = (last - first).inc() //0..0: (0-0)+1

typealias Nat8 = Int
typealias Nat16 = Int
typealias Char16 = Char

typealias Int8 = Byte
typealias Int16 = Short
typealias Int32 = Byte
typealias Int64 = Byte

typealias Rat32 = Float
typealias Rat64 = Double

interface MarkReset { fun mark() fun reset() }
fun <R> MarkReset.positional(op: Producer<R>): R
fun positionalTask(): Closeable //JVM

interaface ReadControl: MarkReset, Closeable {
  val position: Cnt; val estimate: Cnt
  fun skip(n: Cnt)
}
override tailrec fun seek(n: LongCnt) {
  if (n == 0L) return //EOS
  val skipped = this.skip(n)
  if (skipped != 0L) seek(n - skipped)
} // for JVM InputStream
override var position: Idx = 0
  protected set // for JVM InputStream

interface WriteControl: Flushable, Closeable

interface ByteReader {
  fun readByte(): Byte
  fun readTo(destination: Buffer, indices: IdxRange)
  fun readToFill(destination: Buffer)
  fun takeBytes(count: Cnt): Buffer
}
interface ByteWriter {
  fun writeByte(b: Byte)
  fun writeFrom(source: Buffer, indices: IdxRange)
  fun writeAllFrom(source: Buffer)
}

interface DataReader {
  fun readNat8():Nat8 fun readNat16():Nat16
  fun readChar16():Char16
  fun readInt8():Int8 fun readInt16():Int16
  fun readInt32():Int32 fun readInt64():Int64
  fun readRat32():Rat32 fun readRat64():Rat64
}
interface DataWriter {
  fun writeNat8(x:Nat8) fun writeNat16(x:Nat16)
  fun writeChar16(x:Char16)
  fun writeInt8(x:Int8) fun writeInt16(x:Int16)
  fun writeInt32(x:Int32) fun writeInt64(x:Int64)
  fun writeRat32(x:Rat32) fun writeRat64(x:Rat64)
}

enum class ByteOrder { LittleEndian, BigEndian }
interface ByteOrdered { var byteOrder: ByteOrder }
fun systemOrder(): ByteOrder = when (NioByteOrder.nativeOrder()) {
  NioByteOrder.LITTLE_ENDIAN -> ByteOrder.Little
  NioByteOrder.Big_ENDIAN -> ByteOrder.Big
}

abstract class BaseDataReader(private val sourceOrder: ByteOrder): ByteOrdered, DataReader {
  protected val shouldSwap get() = byteOrder != sourceOrder
}

interface Reader: DataReader, ByteReader, ReadControl, ByterOrdered
interface Writer: DataWriter, ByteWriter, WriteControl, ByterOrdered

typealias Shift<I> = I.(Cnt) -> I
typealias ByteSelect<I> = I.(I) -> Byte
typealias ByteUnion<I> = I.(Byte) -> I

1234 -> 1,2,3,4
^popleft(shl(8*n)&and)

inline fun <I> integralToBytes(n: Cnt, byte_left: Byte,
  crossinline shl: Shift<I>, crossinline and: ByteSelect<I>, i: I): Sequence<Byte> = sequence {
  var accumulator = i
  for (_t in 1..n) {
    yield(accumulator.and(byte_left))
    accumulator = accumulator.shl(Byte.SIZE_BITS)
  }
}

1,2,3,4 -> 1234:
(shl&or...&or)^pushright

1,2,3,4 -> 0(zero: I)
1,2,3,4 -> 0 shl 8 or 1
2,3,4 -> 1 shl 8 or 2
3,4 -> 12 shl 8 or 3
...

inline fun <I> bytesToIntegral(zero: I,
  crossinline shl: Shift<I>, crossinline or: ByteUnion<I>, bytes: ByteIterator): I {
  var accumulator = zero
  for (byte in bytes) {
    accumulator = accumulator.shl(Byte.SIZE_BITS).or(byte)
  }
  return accumulator
}