docs: make select-expression & shared state and concurrency runnable

Author: AlexanderPrendota

core/kotlinx-coroutines-core/test/guide/example-select-01.kt

@@ -8,8 +8,6 @@ package kotlinx.coroutines.guide.select01
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.selects.*
-import kotlinx.coroutines.*
-import kotlin.coroutines.*
 
 fun CoroutineScope.fizz() = produce<String> {
     while (true) { // sends "Fizz" every 300 ms
@@ -37,10 +35,12 @@ suspend fun selectFizzBuzz(fizz: ReceiveChannel<String>, buzz: ReceiveChannel<St
 }
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     val fizz = fizz()
     val buzz = buzz()
     repeat(7) {
         selectFizzBuzz(fizz, buzz)
     }
-    coroutineContext.cancelChildren() // cancel fizz & buzz coroutines    
+    coroutineContext.cancelChildren() // cancel fizz & buzz coroutines
+//sampleEnd        
 }

core/kotlinx-coroutines-core/test/guide/example-select-02.kt

@@ -8,7 +8,6 @@ package kotlinx.coroutines.guide.select02
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.selects.*
-import kotlin.coroutines.*
 
 suspend fun selectAorB(a: ReceiveChannel<String>, b: ReceiveChannel<String>): String =
     select<String> {
@@ -25,8 +24,9 @@ suspend fun selectAorB(a: ReceiveChannel<String>, b: ReceiveChannel<String>): St
                 "b -> '$value'"
         }
     }
-
+    
 fun main() = runBlocking<Unit> {
+//sampleStart
     val a = produce<String> {
         repeat(4) { send("Hello $it") }
     }
@@ -36,5 +36,6 @@ fun main() = runBlocking<Unit> {
     repeat(8) { // print first eight results
         println(selectAorB(a, b))
     }
-    coroutineContext.cancelChildren()    
-}
+    coroutineContext.cancelChildren()  
+//sampleEnd      
+}    

core/kotlinx-coroutines-core/test/guide/example-select-03.kt

@@ -8,7 +8,6 @@ package kotlinx.coroutines.guide.select03
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.selects.*
-import kotlin.coroutines.*
 
 fun CoroutineScope.produceNumbers(side: SendChannel<Int>) = produce<Int> {
     for (num in 1..10) { // produce 10 numbers from 1 to 10
@@ -21,6 +20,7 @@ fun CoroutineScope.produceNumbers(side: SendChannel<Int>) = produce<Int> {
 }
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     val side = Channel<Int>() // allocate side channel
     launch { // this is a very fast consumer for the side channel
         side.consumeEach { println("Side channel has $it") }
@@ -30,5 +30,6 @@ fun main() = runBlocking<Unit> {
         delay(250) // let us digest the consumed number properly, do not hurry
     }
     println("Done consuming")
-    coroutineContext.cancelChildren()    
+    coroutineContext.cancelChildren()  
+//sampleEnd      
 }

core/kotlinx-coroutines-core/test/guide/example-select-04.kt

@@ -6,10 +6,9 @@
 package kotlinx.coroutines.guide.select04
 
 import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.selects.*
 import java.util.*
-
+    
 fun CoroutineScope.asyncString(time: Int) = async {
     delay(time.toLong())
     "Waited for $time ms"
@@ -21,6 +20,7 @@ fun CoroutineScope.asyncStringsList(): List<Deferred<String>> {
 }
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     val list = asyncStringsList()
     val result = select<String> {
         list.withIndex().forEach { (index, deferred) ->
@@ -32,4 +32,5 @@ fun main() = runBlocking<Unit> {
     println(result)
     val countActive = list.count { it.isActive }
     println("$countActive coroutines are still active")
+//sampleEnd
 }

core/kotlinx-coroutines-core/test/guide/example-select-05.kt

@@ -8,8 +8,7 @@ package kotlinx.coroutines.guide.select05
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.*
 import kotlinx.coroutines.selects.*
-import kotlin.coroutines.*
-
+    
 fun CoroutineScope.switchMapDeferreds(input: ReceiveChannel<Deferred<String>>) = produce<String> {
     var current = input.receive() // start with first received deferred value
     while (isActive) { // loop while not cancelled/closed
@@ -37,6 +36,7 @@ fun CoroutineScope.asyncString(str: String, time: Long) = async {
 }
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     val chan = Channel<Deferred<String>>() // the channel for test
     launch { // launch printing coroutine
         for (s in switchMapDeferreds(chan)) 
@@ -52,4 +52,5 @@ fun main() = runBlocking<Unit> {
     delay(1000) // give it time to process
     chan.close() // close the channel ... 
     delay(500) // and wait some time to let it finish
+//sampleEnd
 }

core/kotlinx-coroutines-core/test/guide/example-sync-01.kt

@@ -6,8 +6,7 @@
 package kotlinx.coroutines.guide.sync01
 
 import kotlinx.coroutines.*
-import kotlin.system.*
-import kotlin.coroutines.*
+import kotlin.system.*    
 
 suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
     val n = 100  // number of coroutines to launch
@@ -26,8 +25,10 @@ suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
 var counter = 0
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     GlobalScope.massiveRun {
         counter++
     }
     println("Counter = $counter")
+//sampleEnd    
 }

core/kotlinx-coroutines-core/test/guide/example-sync-01b.kt

@@ -7,7 +7,6 @@ package kotlinx.coroutines.guide.sync01b
 
 import kotlinx.coroutines.*
 import kotlin.system.*
-import kotlin.coroutines.*
 
 suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
     val n = 100  // number of coroutines to launch
@@ -27,8 +26,10 @@ val mtContext = newFixedThreadPoolContext(2, "mtPool") // explicitly define cont
 var counter = 0
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     CoroutineScope(mtContext).massiveRun { // use it instead of Dispatchers.Default in this sample and below 
         counter++
     }
     println("Counter = $counter")
+//sampleEnd    
 }

core/kotlinx-coroutines-core/test/guide/example-sync-02.kt

@@ -7,7 +7,6 @@ package kotlinx.coroutines.guide.sync02
 
 import kotlinx.coroutines.*
 import kotlin.system.*
-import kotlin.coroutines.*
 
 suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
     val n = 100  // number of coroutines to launch

core/kotlinx-coroutines-core/test/guide/example-sync-03.kt

@@ -8,7 +8,6 @@ package kotlinx.coroutines.guide.sync03
 import kotlinx.coroutines.*
 import java.util.concurrent.atomic.*
 import kotlin.system.*
-import kotlin.coroutines.*
 
 suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
     val n = 100  // number of coroutines to launch
@@ -27,8 +26,10 @@ suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
 var counter = AtomicInteger()
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     GlobalScope.massiveRun {
         counter.incrementAndGet()
     }
     println("Counter = ${counter.get()}")
+//sampleEnd    
 }

core/kotlinx-coroutines-core/test/guide/example-sync-04.kt

@@ -7,7 +7,6 @@ package kotlinx.coroutines.guide.sync04
 
 import kotlinx.coroutines.*
 import kotlin.system.*
-import kotlin.coroutines.*
 
 suspend fun CoroutineScope.massiveRun(action: suspend () -> Unit) {
     val n = 100  // number of coroutines to launch
@@ -27,10 +26,12 @@ val counterContext = newSingleThreadContext("CounterContext")
 var counter = 0
 
 fun main() = runBlocking<Unit> {
+//sampleStart
     GlobalScope.massiveRun { // run each coroutine with DefaultDispathcer
         withContext(counterContext) { // but confine each increment to the single-threaded context
             counter++
         }
     }
     println("Counter = $counter")
+//sampleEnd    
 }