From ec9802946779794bedcdec5bab2649e19f2886ea Mon Sep 17 00:00:00 2001
From: InsanusMokrassar <ovsyannikov.alexey95@gmail.com>
Date: Wed, 19 Jun 2024 20:03:14 +0600
Subject: [PATCH] get back old function to break less API

---
 .../micro_utils/coroutines/HandleSafely.kt    | 20 ++++++++++++++++
 .../micro_utils/coroutines/LaunchSafely.kt    | 24 ++++++++++++-------
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
index bf104ceaf6c..ce84e2c71fe 100644
--- a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
+++ b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt
@@ -29,6 +29,13 @@ suspend inline fun <T> runCatchingSafely(
     }
 }
 
+suspend inline fun <T, R> R.runCatchingSafely(
+    onException: ExceptionHandler<T>,
+    block: suspend R.() -> T
+): Result<T> = runCatchingSafely<T>(onException) {
+    block()
+}
+
 /**
  * Launching [runCatchingSafely] with [defaultSafelyExceptionHandler] as `onException` parameter
  */
@@ -36,6 +43,12 @@ suspend inline fun <T> runCatchingSafely(
     block: suspend () -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
 
+suspend inline fun <T, R> R.runCatchingSafely(
+    block: suspend R.() -> T
+): Result<T> = runCatchingSafely<T> {
+    block()
+}
+
 //suspend inline fun <T, R> T.runCatchingSafely(
 //    onException: ExceptionHandler<R>,
 //    block: suspend T.() -> R
@@ -94,11 +107,18 @@ suspend inline fun <T> safely(
 suspend inline fun <T> safely(
     block: suspend () -> T
 ): T = safely(defaultSafelyExceptionHandler, block)
+suspend inline fun <T, R> R.safely(
+    block: suspend R.() -> T
+): T = safely<T> { block() }
 
 @Deprecated("Renamed", ReplaceWith("runCatchingSafely(block)", "dev.inmo.micro_utils.coroutines.runCatchingSafely"))
 suspend fun <T> safelyWithResult(
     block: suspend () -> T
 ): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+@Deprecated("Renamed", ReplaceWith("this.runCatchingSafely(block)", "dev.inmo.micro_utils.coroutines.runCatchingSafely"))
+suspend fun <T, R> R.safelyWithResult(
+    block: suspend R.() -> T
+): Result<T> = safelyWithResult<T> { block() }
 
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
diff --git a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSafely.kt b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSafely.kt
index 5e7c6380027..13583d2c622 100644
--- a/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSafely.kt
+++ b/coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSafely.kt
@@ -8,34 +8,42 @@ fun CoroutineScope.launchSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
-    block: suspend () -> Unit
+    block: suspend CoroutineScope.() -> Unit
 ) = launch(context, start) {
-    runCatchingSafely(onException, block = block)
+    runCatchingSafely(onException) {
+        block()
+    }
 }
 
 fun CoroutineScope.launchSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<Unit?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    block: suspend () -> Unit
+    block: suspend CoroutineScope.() -> Unit
 ) = launch(context, start) {
-    runCatchingSafelyWithoutExceptions(onException, block = block)
+    runCatchingSafelyWithoutExceptions(onException) {
+        block()
+    }
 }
 
 fun <T> CoroutineScope.asyncSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    block: suspend () -> T
+    block: suspend CoroutineScope.() -> T
 ) = async(context, start) {
-    runCatchingSafely(onException, block = block)
+    runCatchingSafely(onException) {
+        block()
+    }
 }
 
 fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    block: suspend () -> T
+    block: suspend CoroutineScope.() -> T
 ) = async(context, start) {
-    runCatchingSafelyWithoutExceptions(onException, block = block)
+    runCatchingSafelyWithoutExceptions(onException) {
+        block()
+    }
 }