Collections

fun main() {
    val langs = listOf("Kotlin", "Java", "Go")
    println(langs[0])
    println(langs.size)
    println("Go" in langs)
    println(langs.indexOf("Java"))

    val cart = mutableListOf("milk")
    cart.add("eggs")
    cart += "bread"          // same as add
    cart[0] = "oat milk"     // same as set(0, ...)
    cart.removeAt(1)
    println(cart)
    println(cart.first() + " / " + cart.last())
}

fun evensUpTo(n: Int): List<Int> = buildList {
    for (i in 0..n) {
        if (i % 2 == 0) add(i)
    }
    add(-1)   // a sentinel at the end
}

fun main() {
    val evens = evensUpTo(8)
    println(evens)
    println(List(4) { it * it })      // List(size) { index -> value }
    println(emptyList<String>().isEmpty())
}

fun main() {
    val tags = mutableSetOf("kotlin", "jvm")
    println(tags.add("kotlin"))   // already there
    println(tags.add("android"))
    println(tags)

    val a = setOf(1, 2, 3)
    val b = setOf(2, 3, 4)
    println(a union b)
    println(a intersect b)
    println(a subtract b)
}

fun main() {
    val prices = mapOf("tea" to 3, "coffee" to 4)
    println(prices["tea"])
    println(prices["juice"])
    println(prices["juice"] ?: 0)
    println(prices.keys)

    val counts = mutableMapOf<Char, Int>()
    for (c in "banana") {
        counts[c] = counts.getOrDefault(c, 0) + 1
    }
    println(counts)

    val cache = mutableMapOf<Int, String>()
    println(cache.getOrPut(1) { "computed" })
    println(cache.getOrPut(1) { "not called" })
}

fun main() {
    val scores = intArrayOf(90, 75, 60)
    scores[1] = 80                  // slots are mutable
    println(scores.size)
    println(scores.sum())
    println(scores.contentToString())

    val a = arrayOf("x", "y")
    val b = arrayOf("x", "y")
    println(a == b)                 // reference comparison
    println(a.contentEquals(b))
    println(listOf("x", "y") == listOf("x", "y"))

    val asList = scores.toList()
    println(asList)
}

fun main() {
    val podium = listOf("Ada", "Linus", "Grace")
    for ((i, name) in podium.withIndex()) {
        println("${i + 1}. $name")
    }
    podium.forEachIndexed { i, name -> if (i == 0) println("winner: $name") }
    for (i in podium.indices.reversed()) print("${podium[i]} ")
    println()

    val stock = mapOf("apples" to 4, "pears" to 0)
    for ((fruit, n) in stock) println("$fruit=$n")
}

data class Order(val customer: String, val item: String, val total: Int)

fun main() {
    val orders = listOf(
        Order("ada", "book", 30),
        Order("linus", "pen", 5),
        Order("ada", "lamp", 45),
        Order("grace", "book", 30),
    )
    println(orders.map { it.total })
    println(orders.filter { it.total >= 30 }.map { it.item })
    println(orders.sumOf { it.total })
    println(orders.maxBy { it.total }.item)
    println(orders.sortedByDescending { it.total }.map { it.customer })
    println(orders.groupBy { it.customer }.mapValues { (_, os) -> os.sumOf { it.total } })
    println(orders.associate { it.item to it.total })
    val (big, small) = orders.partition { it.total > 10 }
    println("${big.size} big, ${small.size} small")
    println(orders.map { it.customer }.distinct())
    println(orders.any { it.total > 40 } to orders.all { it.total > 1 })
}

fun main() {
    val sentences = listOf("kotlin is fun", "lists are lists")
    println(sentences.flatMap { it.split(" ") })

    val names = listOf("Ada", "Linus", "Grace")
    val ages = listOf(36, 28)
    println(names.zip(ages))              // stops at the shorter list

    val readings = listOf(3, 5, 4, 8, 6, 7)
    println(readings.chunked(4))
    println(readings.windowed(3).map { it.average() })

    println(readings.fold(0) { acc, n -> acc + n })
    println(readings.reduce { acc, n -> maxOf(acc, n) })
    println(names.fold("") { acc, s -> acc + s.first() })
}

fun main() {
    val xs = listOf(1, 2, 3, 4)

    println("-- list (eager)")
    val a = xs.map { println("map $it"); it * 10 }
        .first { println("check $it"); it > 15 }
    println(a)

    println("-- sequence (lazy)")
    val b = xs.asSequence()
        .map { println("map $it"); it * 10 }
        .first { println("check $it"); it > 15 }
    println(b)
}

fun main() {
    val powersOfTwo = generateSequence(1) { it * 2 }
    println(powersOfTwo.take(8).toList())
    println(powersOfTwo.first { it > 1000 })

    val fibonacci = sequence {
        var a = 0
        var b = 1
        while (true) {
            yield(a)
            val next = a + b
            a = b
            b = next
        }
    }
    println(fibonacci.takeWhile { it < 60 }.joinToString(" "))
}

class Team {
    private val members = mutableListOf("Ada")
    val view: List<String> get() = members          // read-only view
    val snapshot: List<String> get() = members.toList() // copy
    fun join(name: String) { members += name }
}

fun main() {
    val team = Team()
    val v = team.view
    val s = team.snapshot
    team.join("Linus")
    println(v)
    println(s)
}