Programming-Idioms.org

println("Hello world!")

(0..9).forEach {
    println("Hello")
}

repeat(10) {
    println("Hello")
}

for(x in 1..10) {
     println("Hello")
}

fun finish(name: String) { 
  println("My job here is done. Goodbye $name") 
}

fun square(x: Int) = x * x

data class Point(val x: Float, val y: Float)

items.forEach { doSomething(it) }

items.forEach(::doSomething)

for (x in items) doSomething(x)

items.forEachIndexed { i, x -> 
  println("i=$i x=$x") 
}

val x = mapOf("one" to 1, "two" to 2)

val x = mutableMapOf<String, Int>().apply { 
    this["one"] = 1
    this["two"] = 2
}

val x = mutableMapOf<String, Int>()
x["one"] = 1
x["two"] = 2

data class Node(
    val key: Int,
    val left: Node? = null,
    val right: Node? = null
)

x.shuffle()

val y = x.shuffled()

list.random()

x in list

list.contains(x)

mymap.entries.forEach { print("${it.key} ${it.value}") }

mymap.forEach { k, v -> println("$k -> $v") }

Random.nextDouble(a,b)

fun pick(a: Int, b: Int): Int {
    return (a..b).random()
}

fun dfs(bt: BinaryTree) {
    bt.left?.let { dfs(it) }
    f(bt)
    bt.rigth?.let { dfs(it) }
}

x.reverse()

x = x.reversed()

val reversedView = x.asReversed()

fun search(m: Array<Array<Int>>, x: Int): Pair<Int, Int>? {
    m.forEachIndexed { i, row ->
        row.forEachIndexed { j, value ->
            if (value == x) {
                return Pair(i, j)
            }
        }
    }
    return null
}

a = b.also { b = a }

val i = s.toInt()

val i = s.toIntOrNull()

s = "%.2f".format(x)

val x = Array(m, { DoubleArray(n) })

val x = Array(m, { Array(n, { DoubleArray(p) } ) } )

items.sortedBy { it.p }

items.removeAt(i)

fun main() = runBlocking {
    repeat(1000) {
        launch {
            f(it)
        }
    }
}

fun f(i: Int): Int = when (i) {
    0 -> 1
    else -> i * f(i - 1)
}

fun f(i: Int) = if (i == 0) 1 else i * f(i - 1)

fun exp(x: Int, n: Int): Int = when {
    n == 0 -> 1
    n == 1 -> x
    n % 2 == 0 -> exp(x * x, n / 2)
    else -> x * exp(x * x, (n - 1) / 2)
}

val t = s.substring(i, j)

val ok = s.contains(word)

val ok = word in s

inline class VertexId(val id: Int)
data class Vertex(val id: VertexId, val neighbours: Set<VertexId>)
data class Graph(val vertices: Set<Vertex>)

val t = s.reversed()

loop@ for (x in 0..7) {
  for (y in 0..7) {
    val v = m[x][y]
    if ( v < 0) {
       println("found a negative value at [$x][$y]: $v")
       break@loop
     }
  }
}

s.add(i, x)

Thread.sleep(5000L)

val t = s.take(5)

val t = s.takeLast(5)

val s =
    """
    This is my
    multi-line string.
    """

val chunks = s.split("\\s+".toRegex())

while (true) { }

m.containsKey(k)

m.containsValue(v)

val y = listOf(x).joinToString(", ")

val numbers = listOf(1, 2, 3, 4)
val sum = numbers.sum()

val s = i.toString()

(1..1000)
    .map { i ->
        CoroutineScope(Dispatchers.Default).async {
            f(i)
        }
    }
    .awaitAll()
print("Finished")

val y = x.filter(p)

File(f).readText()

System.err.println("$x is negative")

val random = Random(seed=s)

fun main(args: Array<String>) = args.forEach(::println)

exitProcess(0)

println(x::class.simpleName)

val b = s.startsWith(prefix)

b = s.endsWith(suffix)

items.sortWith(c)

val blank = s.isNullOrBlank()

val n = x.size

x = x.toSet().toList()

x = x.distinct()

fun foo() : Pair<String, Boolean> = Pair(5, true)

fun useFoo() {
  val a, b = foo()
}

when {
  c1 -> f1()
  c2 -> f2()
  c3 -> f3()
}

val items = listOf(a, b, c)

val regex = Regex("[0-9]*")
val b = regex.matches(s)

fun String?.isOnlyDigits() = !this.isNullOrEmpty() && this.all { Character.isDigit(it) }

b = File(fb).exists()

val s: String = c.toString()

val planet = "Earth"

var x = items.last()

val ab = a + b

val n = s.length

fun center(x1: int, y1: int, x2: int, y2: int) = Pair((x1 + x2)/2, (y1 + y2)/2)

data class Point(val x: Double, val y: Double)
data class Rectangle(val x1: Double, val y1: Double, val x2: Double, val y2: Double){
  fun center() = Point( x = (x1 + x2)/2, y =(y1 + y2)/2)
}

val t = LocalDate.now().plusDays(1).toString()

exitProcess(0)

fun foo(a : IntArray, idx: IntProgression) = 
  idx.forEach{ a[it] = 42 }
foo(a, 0 .. (m-1) step 2)

val lines = File(path).readLines()

val foo = System.getenv("FOO") ?: "none"

val t = Triple(2.5, "foo", true)

items.find { it == "baz" }
  ?.let { println("found it") }
  ?: println("never found it")

if(items.any { it == "baz" })
  println("found it")
else 
  println("never found it")

String(Base64.getDecoder().decode(s))

val c = items.distinct().size

val (a, b, c) = listOf("A", "B", "C")

val x = if(condition()) "a" else "b"

val s = v.repeat(n)
println(s)

val e = T.BIKE
val s = e.name
println(s)

s.forEachIndexed { i, c ->
  println("Char $i is $c")
}

val s = a + b

val s = "Our sun has $x planets"