can we merge this super-duper useful util?

Author: halotukozak

core/src/main/scala/com/avsystem/commons/SharedExtensions.scala

@@ -1,14 +1,14 @@
 package com.avsystem.commons
 
 import com.avsystem.commons.concurrent.RunNowEC
-import com.avsystem.commons.misc._
+import com.avsystem.commons.misc.*
 
 import scala.annotation.{nowarn, tailrec}
 import scala.collection.{AbstractIterator, BuildFrom, Factory, mutable}
 
 trait SharedExtensions {
 
-  import com.avsystem.commons.SharedExtensionsUtils._
+  import com.avsystem.commons.SharedExtensionsUtils.*
 
   implicit def universalOps[A](a: A): UniversalOps[A] = new UniversalOps(a)
 
@@ -471,8 +471,12 @@ object SharedExtensionsUtils extends SharedExtensions {
     def tapFailure(action: Throwable => Unit): Try[A] = tr match {
       case Success(_) => tr
       case Failure(throwable) =>
-        action(throwable)
+        try action(throwable)
+        catch {
+          case NonFatal(_) => // ignore any exceptions thrown by the action
+        }
         tr
+
     }
   }
 
@@ -515,7 +519,7 @@ object SharedExtensionsUtils extends SharedExtensions {
 
   class PartialFunctionOps[A, B](private val pf: PartialFunction[A, B]) extends AnyVal {
 
-    import PartialFunctionOps._
+    import PartialFunctionOps.*
 
     /**
       * The same thing as `orElse` but with arguments flipped.
@@ -651,7 +655,7 @@ object SharedExtensionsUtils extends SharedExtensions {
 
   class MapOps[M[X, Y] <: BMap[X, Y], K, V](private val map: M[K, V]) extends AnyVal {
 
-    import MapOps._
+    import MapOps.*
 
     def getOpt(key: K): Opt[V] = map.get(key).toOpt
 

core/src/test/scala/com/avsystem/commons/misc/SharedExtensionsTest.scala

@@ -1,11 +1,10 @@
 package com.avsystem.commons.misc
 
+import com.avsystem.commons.CommonAliases.*
+import com.avsystem.commons.SharedExtensions.*
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
-import com.avsystem.commons.SharedExtensions._
-import com.avsystem.commons.CommonAliases._
-
 class SharedExtensionsTest extends AnyFunSuite with Matchers {
   test("mkMap") {
     List.range(0, 3).mkMap(identity, _.toString) shouldEqual
@@ -81,7 +80,7 @@ class SharedExtensionsTest extends AnyFunSuite with Matchers {
   }
 
   test("Future.transformWith") {
-    import com.avsystem.commons.concurrent.RunNowEC.Implicits._
+    import com.avsystem.commons.concurrent.RunNowEC.Implicits.*
     val ex = new Exception
     assert(Future.successful(42).transformWith(t => Future.successful(t.get - 1)).value.contains(Success(41)))
     assert(Future.successful(42).transformWith(_ => Future.failed(ex)).value.contains(Failure(ex)))
@@ -206,4 +205,34 @@ class SharedExtensionsTest extends AnyFunSuite with Matchers {
         |  abc
         | abc""".stripMargin)
   }
+
+  test("Try.tapFailure - Success case") {
+    var actionCalled = false
+    val successTry = Success(42)
+    val result = successTry.tapFailure(_ => actionCalled = true)
+
+    assert(!actionCalled, "Action should not be called for Success")
+    assert(result === successTry, "Original Success should be returned")
+  }
+
+  test("Try.tapFailure - Failure case") {
+    var capturedThrowable: Throwable = null
+    val exception = new RuntimeException("test exception")
+    val failureTry = Failure(exception)
+
+    val result = failureTry.tapFailure(t => capturedThrowable = t)
+
+    assert(capturedThrowable === exception, "Action should be called with the exception")
+    assert(result === failureTry, "Original Failure should be returned")
+  }
+
+  test("Try.tapFailure - Exception in action") {
+    val originalException = new RuntimeException("original exception")
+    val actionException = new RuntimeException("action exception")
+    val failureTry = Failure(originalException)
+
+    val result = failureTry.tapFailure(_ => throw actionException)
+
+    assert(result === failureTry, "Original Failure should be returned even if action throws")
+  }
 }