chore: update for Kotlin 1.3

Author: AlexanderPrendota

examples/01_introduction/01_Hello world.md

@@ -1,13 +1,15 @@
 # Hello world
 
 <div class="language-kotlin" theme="idea" data-min-compiler-version="1.3">
+
 ```kotlin
 package org.kotlinlang.play         // 1
 
 fun main() {                        // 2
     println("Hello, World!")        // 3
 }
 ```
+
 </div>
 
 1. Kotlin code is usually defined in packages. If you don't define one, the default package will be used.
@@ -18,10 +20,12 @@ also, note that semicolons are optional.
 
 For Kotlin versions less than 1.3 `main` function must be defined with parameter:
 
-<div class="language-kotlin" theme="idea">
+<div class="language-kotlin" theme="idea" data-min-compiler-version="1.2">
+
 ```kotlin
 fun main(args: Array<String>) {
     println("Hello, World!")
 }
 ```
+
 </div>

examples/01_introduction/02_String Templates.md

@@ -1,8 +1,9 @@
 # String Templates
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     val greeting = "Kotliner"
 

examples/01_introduction/03_Variables.md

@@ -5,8 +5,9 @@ compiler do the work by inferring it. While Kotlin does not enforce immutability
 In essence use *val* over *var*.
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     var a: String = "initial"  // 1
     println(a)
@@ -15,21 +16,24 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>
 
 1. Declare a mutable variable and initialise it
 2. Declare an immutable variable and initialise it
 3. Declare an immutable variable and initialise it. The compiler infers the type.
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     var e: Int  // 1
     println(e)  // 2
 //sampleEnd
 }
 ```
+
 </div>
 
 1. Declare a variable, but don't initialise it.
@@ -38,10 +42,11 @@ fun main(args: Array<String>) {
 Variable initialization can be postponed, but it must be initialized before the first read.
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 fun someCondition() = true 
 
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     val d: Int  // 1
 
@@ -55,6 +60,7 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>
 
 1. Declare a variable, but don't initialise it.

examples/01_introduction/04_Functions.md

@@ -2,7 +2,8 @@
 
 ### Default parameter values and named arguments
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
 fun printMessage(message: String): Unit {                           // 1
     println(message)
@@ -18,14 +19,15 @@ fun sum(x: Int, y: Int): Int {                                      // 3
 
 fun multiply(x: Int, y: Int) = x * y                                // 4
 
-fun main(args: Array<String>) {
+fun main() {
     printMessage("Hello")                                           // 5                    
     printMessageWithPrefix("Hello", "Log")                          // 6
     printMessageWithPrefix("Hello")                                 // 7
     printMessageWithPrefix(prefix = "Log", message = "Hello")       // 8
     sum(1, 2)
 }
 ```
+
 </div>
 
 1. Create a function that takes a parameter of type string and returns Unit (i.e. no return value).
@@ -41,7 +43,8 @@ fun main(args: Array<String>) {
 
 Member functions and extensions with a single parameter can be turned into infix functions.
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
 fun main(args: Array<String>) {
 
@@ -65,6 +68,7 @@ class Person(val name: String) {
   infix fun likes(other: Person) { likedPeople.add(other) }  // 6
 }
 ```
+
 </div>
 
 1. Defines an infix extension function on `Int`
@@ -80,9 +84,10 @@ Note that the example uses _local functions_ (functions nested into another func
 
 Certain functions can be "upgraded" to operators, allowing to use them with the corresponding operator symbol.
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
 
   operator fun Int.times(str: String) = str.repeat(this)       // 1
@@ -94,6 +99,7 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>
 
 1. This takes the infix function from above one step further using the `operator` modifier.
@@ -105,9 +111,10 @@ fun main(args: Array<String>) {
 
 Varargs allow passing any number of arguments by comma-separating them.
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
   fun printAll(vararg messages: String) {                            // 1
     for (m in messages) println(m)
@@ -126,6 +133,7 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>
 
 1. The `vararg` modifier turns a parameter into a vararg.

examples/01_introduction/05_Null Safety.md

@@ -6,7 +6,7 @@ In an effort to rid the world of `NullPointerException`, variable types in Kotli
 
 ```kotlin
 //sampleStart
-fun main(args: Array<String>) {
+fun main() {
     var neverNull: String = "This can't be null"            // 1
 
     var nullable: String? = "You can keep a null here"      // 2
@@ -32,6 +32,7 @@ Sometimes Kotlin programs need to work with null values, such as when interactin
 representing a truly absent state.  Kotlin provides null tracking to elegantly deal with such situations.
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 //sampleStart
 fun describeString(maybeString: String?): String {              // 1
@@ -43,10 +44,11 @@ fun describeString(maybeString: String?): String {              // 1
 }
 //sampleEnd
 
-fun main(args: Array<String>) {
+fun main() {
     println(describeString(null))
 }
 ```
+
 </div>
 
 

examples/02_advanced/01_namedArguments.md

@@ -1,17 +1,19 @@
 # Named Arguments
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 fun format(userName: String, domain: String) = "$userName@$domain"
 
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     println(format("mario", "example.com"))                         // 1
     println(format(userName = "foo", domain = "bar.com"))           // 2
     println(format(domain = "frog.com", userName = "pepe"))         // 3
 //sampleEnd
 }
 ```
+
 </div>
 
 1. As most of programming languages(Java, C++ etc), Kotlin supports passing arguments to methods and constructors

examples/02_advanced/02_extensionFunctions.md

@@ -1,6 +1,7 @@
 # Extension Functions and Properties
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 data class Item(val name: String, val price: Float)                                   // 1  
 
@@ -12,7 +13,7 @@ fun Order.maxPricedItemName() = this.items.maxBy { it.price }?.name ?: "NO_PRODU
 val Order.commaDelimitedItemNames: String                                             // 3
     get() = items.map { it.name }.joinToString()
 
-fun main(args: Array<String>) {
+fun main() {
 
     val order = Order(listOf(Item("Bread", 25.0F), Item("Wine", 29.0F), Item("Water", 12.0F)))
 
@@ -22,6 +23,7 @@ fun main(args: Array<String>) {
 
 }
 ```
+
 </div>
 
 1. We define simple models of `Item` and `Order`. `Order` can contain arbitrary `Collection` of `Item` s
@@ -34,13 +36,15 @@ is very much like standard function or property signature, with addition that we
 It is even possible to execute extensions on `null` references. In their implementation we can check for `null` reference and based on that we can do any arbitrary logic. Example:
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 //sampleStart
 fun <T> T?.nullSafeToString() = this?.toString() ?: "NULL"  // 1
 //sampleEnd
-fun main(args: Array<String>) {
+fun main() {
     println(null.nullSafeToString())
     println("Kotlin".nullSafeToString())
 }
 ```
+
 </div>

examples/02_advanced/03_Data classes.md

@@ -5,10 +5,11 @@ Everything that's needed to use them in collections, have a useful string
 representation, and create copies is auto-generated.
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 data class User(val name: String, val id: Int)
 
-fun main(args: Array<String>) {
+fun main() {
     val user = User("Alex", 1)
     println(user)                                          // 1
 
@@ -31,6 +32,7 @@ fun main(args: Array<String>) {
     println("id = ${user.component2}")
 }
 ```
+
 </div>
 
 1. Method `toString` is auto-generated, which makes `println` output look nice.

examples/02_advanced/04_Destructuring Declarations.md

@@ -2,14 +2,15 @@
 
 _Destructuring declaration_ syntax can be very handy and save you few lines of code.
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
 fun findMinMax(list: List<Int>): Pair<Int, Int> { 
     // do the math
     return Pair(50, 100) 
 }
 
-fun main(args: Array<String>) {
+fun main() {
 //sampleStart
     val (x, y, z) = arrayOf(5, 10, 15)                              // 1
 
@@ -23,19 +24,21 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>
 
 1. Create a component on the left-hand side to match the arity of the right hand
 2. It can be used to iterate through maps. _name_ and _age_ variables are mapped to key and value now
 3. You can destructure built-in Pairs and Triples, even as return values from functions
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
 data class User(val username: String, val email: String)    // 1
 
 fun getUser() = User("Mary", "[email protected]")
 
-fun main(args: Array<String>) {
+fun main() {
     val user = getUser()
     val (username, email) = user                            // 2
     println(username == user.component1())                  // 3
@@ -44,14 +47,16 @@ fun main(args: Array<String>) {
 
 }
 ```
+
 </div>
 
 1. Define a data class that will be destructured later
 2. Values mapped to object fields
 3. Data class automatically defines the `component1()`, `component2()` corresponding methods, which will be called during destructuring
 4. Use _underscore_ if you don't need one of the values, avoiding the compiler hint indicating unused variable    
 
-<div class="language-kotlin" theme="idea" theme="idea">
+<div class="language-kotlin" theme="idea">
+
 ```kotlin
 class Pair<K, V>(val first: K, val second: V) {  // 1
     operator fun component1(): K {              
@@ -63,12 +68,13 @@ class Pair<K, V>(val first: K, val second: V) {  // 1
     }
 }
 
-fun main(args: Array<String>) {
+fun main() {
     val (num, name) = Pair(1, "one")             // 2
 
     println("num = $num, name = $name")
 }
 ```
+
 </div>
 
 1. Define a custom `Pair` class with `component1()` and `component2()` methods

examples/03_stdlib/01_letFunction.md

@@ -3,6 +3,7 @@
 **let** is a useful function defined in Kotlin Standard Library. It can be used for scoping and null-checks. 
 
 <div class="language-kotlin" theme="idea">
+
 ```kotlin
 import java.io.File
 
@@ -14,6 +15,7 @@ fun main(args: Array<String>) {
 //sampleEnd
 }
 ```
+
 </div>