Add withEach and withEachIndexed Iterable extensions, prompt function (…

…#17)

* add withEach and withEachIndexed Iterable extensions

* add prompt function

* added Prompt documentation

* fixed detekt compliance

README.md

@@ -82,6 +82,8 @@ Following functions are the most popular ones.
 * `Iterable<A>.zip(b: Iterable<B>, c: Iterable<C>, transform: (a: A, b: B, c: C) -> V)` - zip with three collections instead of two
 * `Iterable<T>.sumByFloat(selector: (T) -> Float)` - sums iterable by float selector, because `sumOf` from stdlib does not have
   implementation for Floats
+* `Iterable<T>.withEach(action: T.() -> Unit)` - performs the given action with each element as a receiver
+* `Iterable<T>.withEachIndexed(action: T.(index: Int) -> Unit)` - performs the given action with each element as a receiver, providing sequential index with the element
 
 #### [Map Extensions](src/main/kotlin/pw/forst/katlib/MapExtensions.kt)
 
@@ -230,3 +232,7 @@ byteBuffer.applyIf(shouldReadInt) { getInt() }
 * `Array<out T?>.filterNotNull(): Array<T>` - returns an array containing all elements that are not `null`
 * `Array<out T>.minus(element: T): Array<T>` - returns an array containing all elements of the original collection without the first occurrence of the given element
 * `Array<out T>.minus(elements: Array<out T>): Array<T>` - returns an array containing all elements of the original collection except the elements contained in the given elements array
+
+#### [Prompt](src/main/kotlin/pw/forst/katlib/Prompt.kt)
+
+* `prompt(promptText: String, exceptionHandler: (e: Exception) -> String? = { null }, transform: (input: String) -> R): R` - prompts user and applies transform to input, invokes exceptionHandler if transform threw an Exception, and repeats prompt

detekt-config.yml

@@ -257,7 +257,7 @@ exceptions:
     active: true
   TooGenericExceptionCaught:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**', '**/Prompt.kt']
     exceptionNames:
       - 'ArrayIndexOutOfBoundsException'
       - 'Error'

src/main/kotlin/pw/forst/katlib/IterableExtensions.kt

@@ -643,3 +643,13 @@ inline fun <T> Iterable<T>.sumByFloat(selector: (T) -> Float): Float {
     return sum
 }
 
+/**
+ * Performs the given action with each element as a receiver.
+ */
+inline fun <T> Iterable<T>.withEach(action: T.() -> Unit) = forEach { it.action() }
+
+/**
+ * Performs the given [action] with each element as a receiver, providing sequential index with the element.
+ * @param [action] function that takes the index of an element and performs the action on the element.
+ */
+inline fun <T> Iterable<T>.withEachIndexed(action: T.(index: Int) -> Unit) = forEachIndexed{ index, it -> it.action(index)}

src/main/kotlin/pw/forst/katlib/Prompt.kt

@@ -0,0 +1,27 @@
+package pw.forst.katlib
+
+/**
+ * Prints @param [promptText], reads input from console and applies @param [transform] to it.
+ * If @param [transform] throws an exception on user input, @param [exceptionHandler] will be invoked,
+ * and prompt will be repeated.
+ *
+ * Example: snippet below will ask user for input until given input can be parsed to Double
+ * ```
+ * prompt(
+ * 	"input number:",
+ * 	{ "this is not a number" },
+ * )
+ * { it.toFloat() }
+ * ```
+ * @return user input with transform applied
+ */
+fun <R> prompt(promptText: String, exceptionHandler: (e: Exception) -> String? = { null }, transform: (input: String) -> R): R {
+	while (true) {
+		print(promptText)
+		try {
+			return transform(readln())
+		} catch (e: Exception) {
+			exceptionHandler(e)?.let { println(it) }
+		}
+	}
+}

src/test/kotlin/pw/forst/katlib/IterableExtensionsTest.kt

@@ -352,4 +352,21 @@ internal class IterableExtensionsTest {
         val empty = listOf<Float>()
         assertEquals(0f, empty.sumByFloat { it * 2f })
     }
+
+    @Test
+    fun `test withEach`() {
+        val pairs = List(100){ Pair(it, it * 2) }
+        pairs.withEach {
+            assertEquals(first * 2, second)
+        }
+    }
+
+    @Test
+    fun `test withEachIndexed`()
+    {
+        val pairs = List(100){ it }
+        pairs.withEachIndexed { index ->
+            assertEquals(index, this)
+        }
+    }
 }