import kotlin.collections.slice

fun main() {
    // In Kotlin, we use Lists instead of slices. Lists are typed only by
    // the elements they contain. An uninitialized list is empty but not null.
    var s: List<String> = listOf()
    println("uninit: $s ${s.isEmpty()} ${s.size == 0}")

    // To create an empty list with non-zero size, we can use MutableList
    s = MutableList(3) { "" }
    println("emp: $s len: ${s.size}")

    // We can set and get just like with arrays
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    println("set: $s")
    println("get: ${s[2]}")

    // size returns the length of the list as expected
    println("len: ${s.size}")

    // In Kotlin, we use the + operator or the mutableListOf function
    // to add elements to a list
    s = s + "d"
    s = s + listOf("e", "f")
    println("apd: $s")

    // Lists can be copied using the toList() function
    val c = s.toList()
    println("cpy: $c")

    // Kotlin supports list slicing with a similar syntax
    val l = s.slice(2..4)
    println("sl1: $l")

    // This slices up to (but excluding) index 5
    val l2 = s.slice(0 until 5)
    println("sl2: $l2")

    // And this slices from (and including) index 2 to the end
    val l3 = s.slice(2 until s.size)
    println("sl3: $l3")

    // We can declare and initialize a list in a single line as well
    val t = listOf("g", "h", "i")
    println("dcl: $t")

    // Kotlin has built-in list comparison
    val t2 = listOf("g", "h", "i")
    if (t == t2) {
        println("t == t2")
    }

    // Lists can be composed into multi-dimensional data structures
    val twoD = List(3) { i ->
        List(i + 1) { j -> i + j }
    }
    println("2d: $twoD")
}