WIP flows

Author: reczkom

Flow/Buffering/Buffer/src/Main.kt

@@ -0,0 +1,21 @@
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlin.system.measureTimeMillis
+
+fun main() = runBlocking {
+    val numbers = flow {
+        for (i in 1..5) {
+            delay(100)
+            emit(i)
+        }
+    }
+
+    val time = measureTimeMillis {
+        numbers.buffer().collect {
+            delay(300)
+            println(it)
+        }
+    }
+
+    println("time used: $time ms")
+}

Flow/Buffering/Buffer/task-info.yaml

@@ -0,0 +1,10 @@
+type: edu
+files:
+  - name: src/Main.kt
+    visible: true
+    placeholders:
+      - offset: 698
+        length: 9
+        placeholder_text: ""
+  - name: test/Test.kt
+    visible: false

Flow/Buffering/Buffer/task.md

@@ -0,0 +1,8 @@
+# Buffer
+
+Assume that the production and the consumption of values takes both some time. Normally emitting new values
+will be triggered if the collection of the last one is finished. 
+So we need in this example for each value approx. 400ms. With *buffer* we can collect the next value(s) before the 
+current value is processed.
+
+Try it out.

Flow/Buffering/Buffer/test/Test.kt

@@ -0,0 +1,13 @@
+import org.junit.jupiter.api.Test
+import kotlin.system.measureTimeMillis
+import kotlin.test.assertTrue
+
+
+class Test {
+    @Test
+    fun testSolution() {
+        val time = measureTimeMillis { main() }
+
+        assertTrue(time < 2000)
+    }
+}

Flow/Buffering/Conflation/src/Main.kt

@@ -0,0 +1,16 @@
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+fun main() = runBlocking {
+    val numbers = flow {
+        for (i in 1..5) {
+            delay(100)
+            emit(i)
+        }
+    }
+
+    numbers.conflate().collect {
+        delay(300)
+        println(it)
+    }
+}

Flow/Buffering/Conflation/task-info.yaml

@@ -0,0 +1,10 @@
+type: output
+files:
+  - name: src/Main.kt
+    visible: true
+    placeholders:
+      - offset: 490
+        length: 11
+        placeholder_text: ""
+  - name: test/output.txt
+    visible: false

Flow/Buffering/Conflation/task.md

@@ -0,0 +1,7 @@
+# Conflation
+
+
+Sometimes it is not necessary to process each value (if they are produced faster than collected) but the
+most recent ones. 
+
+Use *conflate* to buffer the collection and have a look to the result.

Flow/Buffering/Conflation/test/output.txt

@@ -0,0 +1,3 @@
+1
+3
+5

Flow/Buffering/Latest/src/Main.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+fun main() = runBlocking {
+    val numbers = flow {
+        for (i in 1..5) {
+            delay(100)
+            emit(i)
+        }
+    }
+
+    numbers.collectLatest {
+        println("collect $it")
+        delay(300)
+        println(it)
+    }
+}

Flow/Buffering/Latest/task-info.yaml

@@ -0,0 +1,10 @@
+type: output
+files:
+  - name: src/Main.kt
+    visible: true
+    placeholders:
+      - offset: 524
+        length: 6
+        placeholder_text: ""
+  - name: test/output.txt
+    visible: false