minor fix for typo, indent, link, and sample code (JetBrains#3179)

* minor fix for typo, indent, link, and sample code

* chore: rollback the wrong article

* chore: new line added

* chore: fix indents

* chore: add bells and whistles

* Update kotlin-tips.md

* fix sample code, remove versions which have duplicated content, keep only 1 version

Co-authored-by: Andrey Polyakov <koshachy@gmail.com>

Author: LiYing2010

docs/topics/coding-conventions.md

@@ -879,7 +879,7 @@ a type alias for it:
 typealias MouseClickHandler = (Any, MouseEvent) -> Unit
 typealias PersonIndex = Map<String, Person>
 ```
-If you use a private or internal type alias for avoiding name collision, prefer the `import … as …` mentioned in 
+If you use a private or internal type alias for avoiding name collision, prefer the `import ... as ...` mentioned in 
 [Packages and Imports](packages.md).
 
 ### Lambda parameters

docs/topics/competitive-programming.md

@@ -41,7 +41,7 @@ features as [tail recursion](functions.md#tail-recursive-functions):
 ```kotlin
 tailrec fun removeZeroes(x: Int): Int =
     if (x % 10 == 0) removeZeroes(x / 10) else x
-    
+
 fun f(x: Int) = removeZeroes(x + 1)
 ```
 
@@ -80,7 +80,6 @@ fun main() {
     while (reached.add(n)) n = f(n) // iterate function f
     println(reached.size) // print answer to the output
 }
-
 ```
 
 There is no need to handle the case of misformatted input in competitive programming. An input format is always precisely
@@ -127,17 +126,17 @@ the following helper functions for reading inputs in competitive programming:
 <tab title="Kotlin 1.6.0 and later" group-key="kotlin-1-6">
 
 ```kotlin
-private fun readInt() = readln().toInt()
-private fun readStr() = readln().toString()
+private fun readStr() = readln() // string line
+private fun readInt() = readStr().toInt() // single int
 // similar for other types you'd use in your solutions
 ```
 
 </tab>
 <tab title="Earlier versions" group-key="kotlin-1-5">
 
 ```kotlin
-private fun readInt() = readLn().toInt()
-private fun readStr() = readLn().toString()
+private fun readStr() = readLine()!! // string line
+private fun readInt() = readStr().toInt() // single int
 // similar for other types you'd use in your solutions
 ```
 
@@ -224,18 +223,20 @@ you can have the following list of helper input-reading functions:
 <tab title="Kotlin 1.6.0 and later" group-key="kotlin-1-6">
 
 ```kotlin
-private fun readInt() = readln().toInt() // single int
-private fun readStrings() = readln().split(" ") // list of strings
+private fun readStr() = readln() // string line
+private fun readInt() = readStr().toInt() // single int
+private fun readStrings() = readStr().split(" ") // list of strings
 private fun readInts() = readStrings().map { it.toInt() } // list of ints
 ```
 
 </tab>
 <tab title="Earlier versions" group-key="kotlin-1-5">
 
 ```kotlin
-private fun readLn() = readLine()!! // string line
-private fun readInt() = readLn().toInt() // single int
-private fun readStrings() = readLn().split(" ") // list of strings
+private fun readStr() = readLine()!! // string line
+private fun readInt() = readStr().toInt() // single int
+private fun readStrings() = readStr().split(" ") // list of strings
+private fun readInts() = readStrings().map { it.toInt() } // list of ints
 ```
 
 </tab>
@@ -244,29 +245,13 @@ private fun readStrings() = readLn().split(" ") // list of strings
 With these helpers, the part of code for reading input becomes simpler, closely following the input 
 specification in the problem statement line by line:
 
-<tabs group="kotlin-versions">
-<tab title="Kotlin 1.6.0 and later" group-key="kotlin-1-6">
-
 ```kotlin
 // read input
 val n = readInt()
-val s = readln()
+val s = readStr()
 val fl = readInts()
 ```
 
-</tab>
-<tab title="Earlier versions" group-key="kotlin-1-5">
-
-```kotlin
-// read input
-val n = readInt()
-val s = readLn()
-val fl = readInts()
-```
-
-</tab>
-</tabs>
-
 Note that in competitive programming it is customary to give variables shorter names than it is 
 typical in industrial programming practice, since the code is to be written just once and not supported thereafter. 
 However, these names are usually still mnemonic — `a` for arrays,
@@ -286,7 +271,7 @@ In Kotlin this line can be concisely parsed with the following statement using
 from a list of integers:
 
 ```kotlin
-val (n, k) = readInts() 
+val (n, k) = readInts()
 ```
 
 It might be temping to use JVM's `java.util.Scanner` class to parse less structured 
@@ -323,4 +308,3 @@ is not perfect, and it is still worth familiarizing yourself with Kotlin and lea
 
 A great resource to study Kotlin syntax and API of the Kotlin standard library are
 [Kotlin Koans](koans.md).
-

docs/topics/components-stability.md

@@ -44,7 +44,7 @@ Each Kotlin project has two GitHub badges describing its stability and support s
     * ![Beta stability level](https://kotl.in/badges/beta.svg){type="joined"} stands for **Beta**
     * ![Stable stability level](https://kotl.in/badges/stable.svg){type="joined"} stands for **Stable**
 
-* **Support** status. This shows our commitment to maintaining a project and helping users to solve their problems
+* **Support** status. This shows our commitment to maintaining a project and helping users to solve their problems.
   The level of support is unified for all JetBrains products.  
   [See the JetBrains Confluence document for details](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub).
 

docs/topics/configure-build-for-eap.md

@@ -41,7 +41,7 @@ plugins {
 }
 
 repositories {
-   mavenCentral()
+    mavenCentral()
 }
 ```
 
@@ -144,4 +144,4 @@ In the sample Maven project definition, replace `KOTLIN-EAP-VERSION` with the ac
         </plugins>
     </build>
 </project>
-```
+```

docs/topics/gradle.md

@@ -61,7 +61,7 @@ require the `kotlin-multiplatform` plugin. [Learn more about the plugin](multipl
 
 ```kotlin
 plugins {
-  kotlin("multiplatform") version "%kotlinVersion%"
+    kotlin("multiplatform") version "%kotlinVersion%"
 }
 ```
 
@@ -70,7 +70,7 @@ plugins {
 
 ```groovy
 plugins {
-  id 'org.jetbrains.kotlin.multiplatform' version '%kotlinVersion%'
+    id 'org.jetbrains.kotlin.multiplatform' version '%kotlinVersion%'
 }
 ```
 
@@ -82,7 +82,7 @@ plugins {
 To target the JVM, apply the Kotlin JVM plugin.
 
 <tabs group="build-script">
-    <tab title="Kotlin" group-key="kotlin">
+<tab title="Kotlin" group-key="kotlin">
 
 ```kotlin
 plugins {
@@ -116,7 +116,7 @@ Applying Kotlin plugins with `apply` in the Kotlin Gradle DSL is not recommended
 
 Kotlin sources and Java sources can be stored in the same folder, or they can be placed in different folders. The default convention is to use different folders:
 
-```groovy
+```text
 project
     - src
         - main (root)
@@ -479,7 +479,7 @@ plugin won't override it or add a second standard library.
 
 If you do not need a standard library at all, you can add the opt-out option to the `gradle.properties`:
 
-```kotlin
+```properties
 kotlin.stdlib.default.dependency=false
 ```
 
@@ -1088,18 +1088,18 @@ You can specify arguments for a specific task:
 ```kotlin
 tasks.withType<CompileUsingKotlinDaemon>().configureEach {
     kotlinDaemonJvmArguments.set(listOf("-Xmx486m", "-Xms256m", "-XX:+UseParallelGC"))
-    }
+}
 ```
-  
+
 </tab>
 <tab title="Groovy" group-key="groovy">
 
 ```groovy
 tasks.withType(CompileUsingKotlinDaemon::class).configureEach { task ->
     task.kotlinDaemonJvmArguments.set(["-Xmx1g", "-Xms512m"])
-    }
+}
 ```
-  
+
 </tab>
 </tabs>
 
@@ -1158,7 +1158,7 @@ The available values for the `compilerExecutionStrategy` task property are:
 2. `org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy.IN_PROCESS`
 3. `org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy.OUT_OF_PROCESS`
 
-Use the task property `compilerExecutionStrategy` in your buildscripts:
+Use the task property `compilerExecutionStrategy` in your build scripts:
 
 <tabs group="build-script">
 <tab title="Kotlin" group-key="kotlin">
@@ -1185,7 +1185,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 
 tasks.withType(KotlinCompile)
     .configureEach {
-         compilerExecutionStrategy.set(KotlinCompilerExecutionStrategy.IN_PROCESS)
+        compilerExecutionStrategy.set(KotlinCompilerExecutionStrategy.IN_PROCESS)
     }
 ```
 

docs/topics/js/js-project-setup.md

@@ -323,7 +323,7 @@ To run tests, execute the standard lifecycle `check` task:
 ./gradlew check
 ```
          
-To specify envirnoment variables used by your Node.js test runners (for example, to pass external information to your tests, or to fine-tune package resolution), use the `environment` function with a key-value pair inside the `testTask` block in your build script:
+To specify environment variables used by your Node.js test runners (for example, to pass external information to your tests, or to fine-tune package resolution), use the `environment` function with a key-value pair inside the `testTask` block in your build script:
 
 ```groovy
 kotlin {

docs/topics/jvm/java-to-kotlin-collections-guide.md

@@ -109,7 +109,7 @@ In Java, there are mutable collections:
 ```java
 // Java
 // This list is mutable!
-public List<Customer> getCustomers() { … }
+public List<Customer> getCustomers() { ... }
 ```
 {id="mutability-java"}
 

docs/topics/kapt.md

@@ -142,7 +142,7 @@ tasks.withType<org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask>()
 ```groovy
 tasks.withType(org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask.class)
     .configureEach {
-         kaptProcessJvmArgs.add('-Xmx512m')
+        kaptProcessJvmArgs.add('-Xmx512m')
     }
 ```
 
@@ -182,7 +182,7 @@ kapt.classloaders.cache.disableForProcessors=[annotation processors full names]
 Get a performance statistics on the annotation processors execution using the `-Kapt-show-processor-timings` plugin option. 
 An example output:
 
-```kotlin
+```text
 Kapt Annotation Processing performance report:
 com.example.processor.TestingProcessor: total: 133 ms, init: 36 ms, 2 round(s): 97 ms, 0 ms
 com.example.processor.AnotherProcessor: total: 100 ms, init: 6 ms, 1 round(s): 93 ms
@@ -191,7 +191,7 @@ com.example.processor.AnotherProcessor: total: 100 ms, init: 6 ms, 1 round(s): 9
 You can dump this report into a file with the plugin option [`-Kapt-dump-processor-timings` (`org.jetbrains.kotlin.kapt3:dumpProcessorTimings`)](https://github.com/JetBrains/kotlin/pull/4280). 
 The following command will run kapt and dump the statistics to the `ap-perf-report.file` file:
 
-```kotlin
+```bash
 kotlinc -cp $MY_CLASSPATH \
 -Xplugin=kotlin-annotation-processing-SNAPSHOT.jar -P \
 plugin:org.jetbrains.kotlin.kapt3:aptMode=stubsAndApt,\
@@ -233,7 +233,7 @@ The statistics will appear in the logs with the `info` level. You'll see the `An
 statistics on the execution time of each annotation processor. After these lines, there will be the `Generated files report:` line 
 followed by statistics on the number of generated files for each annotation processor. For example:
 
-```kotlin
+```text
 [INFO] Annotation processor stats:
 [INFO] org.mapstruct.ap.MappingProcessor: total: 290 ms, init: 1 ms, 3 round(s): 289 ms, 0 ms, 0 ms
 [INFO] Generated files report:
@@ -257,7 +257,7 @@ To run kapt with compile avoidance:
 * Add the annotation processor dependencies to the `kapt*` configurations manually as described [above](#using-in-gradle).
 * Turn off the discovery of annotation processors in the compile classpath by adding this line to your `gradle.properties` file:
 
-```
+```properties
 kapt.include.compile.classpath=false
 ```
 
@@ -268,7 +268,7 @@ Currently, annotation processing can be incremental only if all annotation proce
 
 To disable incremental annotation processing, add this line to your `gradle.properties` file:
 
-```
+```properties
 kapt.incremental.apt=false
 ```
 

docs/topics/kotlin-tips.md

@@ -6,55 +6,55 @@ Kotlin Tips is a series of short videos where members of the Kotlin team show ho
 
 ## null + null in Kotlin
 
-What happens when you add `null + null` in Kotlin, and what does it return? Sebastian addresses this mystery in our latest quick tip. Along the way, he also shows why there's no reason to be scared of nullables: 
+What happens when you add `null + null` in Kotlin, and what does it return? Sebastian Aigner addresses this mystery in our latest quick tip. Along the way, he also shows why there's no reason to be scared of nullables: 
 
 <video width="560" height="315" href="wwplVknTza4" title="Kotlin Tips: null + null in Kotlin"/>
 
 ## Deduplicating collection items
 
-Got a Kotlin collection that contains duplicates? Need a collection with only unique items? Let Sebastian show you how to remove duplicates from your lists, or turn them into sets in this Kotlin tip: 
+Got a Kotlin collection that contains duplicates? Need a collection with only unique items? Let Sebastian Aigner show you how to remove duplicates from your lists, or turn them into sets in this Kotlin tip: 
 
 <video width="560" height="315" href="ECOf0PeSANw" title="Kotlin Tips: Deduplicating Collection Items"/>
 
 ## The suspend and inline mystery
 
-How come functions like [`repeat()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/repeat.html), [`map()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/map.html) and [`filter()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/filter.html) accept suspending functions in their lambdas, even though their signatures aren't coroutines-aware? In this episode of Kotlin Tips Sebastian solves the riddle: it has something to do with the inline modifier:
+How come functions like [`repeat()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/repeat.html), [`map()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/map.html) and [`filter()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/filter.html) accept suspending functions in their lambdas, even though their signatures aren't coroutines-aware? In this episode of Kotlin Tips Sebastian Aigner solves the riddle: it has something to do with the inline modifier:
 
 <video width="560" height="315" href="R2395u7SdcI" title="Kotlin Tips: The Suspend and Inline Mystery"/>
 
 ## Unshadowing declarations with their fully qualified name
 
-Shadowing means having two declarations in a scope have the same name. So, how do you pick? In this episode of Kotlin Tips Sebastian shows you a simple Kotlin trick to call exactly the function that you need, using the power of fully qualified names:
+Shadowing means having two declarations in a scope have the same name. So, how do you pick? In this episode of Kotlin Tips Sebastian Aigner shows you a simple Kotlin trick to call exactly the function that you need, using the power of fully qualified names:
 
 <video width="560" height="315" href="mJRzF9WtCpU" title="Kotlin Tips: Unshadowing Declarations"/>
 
 ## Return and throw with the Elvis operator
 
-[Elvis](null-safety.md#elvis-operator) has entered the building once more! Seb explains why the operator is named after the famous singer, and how you can use `?:` in Kotlin to return or throw. The magic behind the scenes? [The Nothing type](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html).
+[Elvis](null-safety.md#elvis-operator) has entered the building once more! Sebastian Aigner explains why the operator is named after the famous singer, and how you can use `?:` in Kotlin to return or throw. The magic behind the scenes? [The Nothing type](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html).
 
 <video width="560" height="315" href="L8aFK7QrbA8" title="Kotlin Tips: Return and Throw with the Elvis Operator"/>
 
 ## Destructuring declarations
 
-With [destructuring declarations](destructuring-declarations.md) in Kotlin, you can create multiple variables from a single object, all at once. In this video Sebastian shows you a selection of things that can be destructured – pairs, lists, maps, and more. And what about your own objects? Kotlin's component functions provide an answer for those as well:
+With [destructuring declarations](destructuring-declarations.md) in Kotlin, you can create multiple variables from a single object, all at once. In this video Sebastian Aigner shows you a selection of things that can be destructured – pairs, lists, maps, and more. And what about your own objects? Kotlin's component functions provide an answer for those as well:
 
 <video width="560" height="315" href="zu1PUAvk_Lw" title="Kotlin Tips: Destructuring Declarations"/>
 
 ## Operator functions with nullable values
 
-In Kotlin, you can override operators like addition and subtraction for your classes and supply your own logic. But what if you want to allow null values, both on their left and right sides? In this video, Sebastian answers this question:
+In Kotlin, you can override operators like addition and subtraction for your classes and supply your own logic. But what if you want to allow null values, both on their left and right sides? In this video, Sebastian Aigner answers this question:
 
 <video width="560" height="315" href="x2bZJv8i0vw" title="Kotlin Tips: Operator Functions With Nullable Values"/>
 
 ## Timing code
 
-Watch Seb give a quick overview of the [`measureTimedValue()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.time/measure-timed-value.html) function, and learn how you can time your code:
+Watch Sebastian Aigner give a quick overview of the [`measureTimedValue()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.time/measure-timed-value.html) function, and learn how you can time your code:
 
 <video width="560" height="315" href="j_LEcry7Pms" title="Kotlin Tips: Timing Code"/>
 
 ## Improving loops
 
-In this video, Sebastian will demonstrate how to improve [loops](control-flow.md#for-loops) to make your code more readable, understandable, and concise:
+In this video, Sebastian Aigner will demonstrate how to improve [loops](control-flow.md#for-loops) to make your code more readable, understandable, and concise:
 
 <video width="560" height="315" href="i-kyPp1qFBA" title="Kotlin Tips: Improving Loops"/>
 
@@ -66,7 +66,7 @@ In this episode, Kate Petrova shows three tips to help you work with [Strings](s
 
 ## Doing more with the Elvis operator
 
-In this video, Sebastian will show how to add more logic to the [Elvis operator](null-safety.md#elvis-operator), such as logging to the right part of the operator:
+In this video, Sebastian Aigner will show how to add more logic to the [Elvis operator](null-safety.md#elvis-operator), such as logging to the right part of the operator:
 
 <video width="560" height="315" href="L9wqYQ-fXaM" title="Kotlin Tips: The Elvis Operator"/>
 

docs/topics/ksp/ksp-multiplatform.md

@@ -44,7 +44,7 @@ In a multiplatform project, Kotlin compilation may happen multiple times (`main`
 So is symbol processing. A symbol processing task is created whenever there is a Kotlin compilation task and a
 corresponding `ksp<Target>` or `ksp<SourceSet>` configuration is specified.
 
-For example, in the above `build.gradle.kts`, there are 4 compilations: common/metadata, JVM main, Linux x64 main, Linux x64 test,
+For example, in the above `build.gradle.kts`, there are 4 compilation tasks: common/metadata, JVM main, Linux x64 main, Linux x64 test,
 and 3 symbol processing tasks: common/metadata, JVM main, Linux x64 test.
 
 ## Avoid the `ksp(...)` configuration on KSP 1.0.1+