Rename Dsl.TryCatch to keywords.TryCatch.DslComposer

Author: Atry

Dsl/src/main/scala/com/thoughtworks/dsl/Dsl.scala

@@ -408,130 +408,6 @@ object Dsl extends LowPriorityDsl0 {
     }
   }
 
-  @implicitNotFound(
-    "The `try` ... `catch` expression cannot contain !-notation inside a function that returns ${OuterDomain}."
-  )
-  @deprecated(
-    "Dsl.TryCatch / Dsl.TryFinally / Dsl.TryCatchFinally will be removed",
-    "2.0.0"
-  )
-  trait TryCatch[Value, OuterDomain, BlockDomain] {
-    def tryCatch(
-        block: BlockDomain !! Value,
-        catcher: Catcher[BlockDomain !! Value],
-        outerSuccessHandler: Value => OuterDomain
-    ): OuterDomain
-  }
-
-  private[dsl] trait LowPriorityTryCatch {
-    implicit def liftFunction1TryCatch[Value, OuterDomain, BlockDomain, State](
-        implicit restTryCatch: TryCatch[Value, OuterDomain, BlockDomain]
-    ): TryCatch[Value, State => OuterDomain, State => BlockDomain] = {
-      (
-          block: (State => BlockDomain) !! Value,
-          catcher: Catcher[(State => BlockDomain) !! Value],
-          outerSuccessHandler: Value => State => OuterDomain
-      ) => (state: State) =>
-        def withState(blockContinuation: (State => BlockDomain) !! Value) = {
-          (blockHandler: (Value => BlockDomain)) =>
-            blockContinuation { (value: Value) => (state: State) =>
-              blockHandler(value)
-            }(state)
-        }
-
-        restTryCatch.tryCatch(
-          withState(block),
-          catcher.andThen(withState _),
-          outerSuccessHandler(_)(state)
-        )
-    }
-  }
-
-  object TryCatch extends LowPriorityTryCatch {
-
-    implicit def throwableContinuationTryCatch[LeftDomain, Value]
-        : TryCatch[Value, LeftDomain !! Throwable, LeftDomain !! Throwable] = {
-
-      (
-          block: LeftDomain !! Throwable !! Value,
-          catcher: Catcher[LeftDomain !! Throwable !! Value],
-          outerSuccessHandler: Value => LeftDomain !! Throwable
-      ) => outerFailureHandler =>
-        def innerFailureHandler(e: Throwable): LeftDomain = {
-          catcher.lift(e) match {
-            case None =>
-              outerFailureHandler(e)
-            case Some(recovered) =>
-              @inline
-              def recoveredHandler(): LeftDomain = {
-                locally {
-                  try {
-                    recovered(outerSuccessHandler)
-                  } catch {
-                    case NonFatal(nativeThrown) =>
-                      return outerFailureHandler(nativeThrown)
-                  }
-                }(outerFailureHandler)
-              }
-
-              recoveredHandler()
-          }
-        }
-
-        def runBlock(): LeftDomain = {
-          (try {
-            block { a => hookedFailureHandler =>
-              @inline
-              def successHandler(): LeftDomain = {
-                locally {
-                  try {
-                    outerSuccessHandler(a)
-                  } catch {
-                    case NonFatal(nativeThrown) =>
-                      return outerFailureHandler(nativeThrown)
-                  }
-                }(outerFailureHandler)
-              }
-
-              successHandler()
-            }
-          } catch {
-            case NonFatal(e) =>
-              return innerFailureHandler(e)
-          })(innerFailureHandler)
-        }
-        runBlock()
-    }
-
-    implicit def futureTryCatch[BlockValue, OuterValue](implicit
-        executionContext: ExecutionContext
-    ): TryCatch[BlockValue, Future[OuterValue], Future[BlockValue]] = {
-      (
-          block: Future[BlockValue] !! BlockValue,
-          catcher: Catcher[Future[BlockValue] !! BlockValue],
-          outerSuccessHandler: BlockValue => Future[OuterValue]
-      ) =>
-        catchNativeException(block)
-          .recoverWith { case e: Throwable =>
-            def recover(): Future[BlockValue] = {
-              (try {
-                catcher.lift(e)
-              } catch {
-                case NonFatal(extractorException) =>
-                  return Future.failed(extractorException)
-              }) match {
-                case None =>
-                  Future.failed(e)
-                case Some(recovered) =>
-                  catchNativeException(recovered)
-              }
-            }
-            recover()
-          }
-          .flatMap(outerSuccessHandler)
-    }
-  }
-
   @implicitNotFound(
     "The `try` ... `finally` expression cannot contain !-notation inside a function that returns ${OuterDomain}."
   )

build.sbt

@@ -186,6 +186,8 @@ lazy val `domains-scalaz` =
       reset % Test,
       `keywords-Monadic`,
       `keywords-Return`,
+      `keywords-TryCatch`,
+      `keywords-TryFinally`,
       `keywords-Shift` % Test,
       `keywords-Yield` % Test
     )

domains-scalaz/src/main/scala/com/thoughtworks/dsl/domains/scalaz.scala

@@ -1,4 +1,5 @@
-package com.thoughtworks.dsl.domains
+package com.thoughtworks.dsl
+package domains
 
 import com.thoughtworks.dsl.Dsl
 import com.thoughtworks.dsl.Dsl.!!
@@ -145,7 +146,6 @@ object scalaz extends scalaz.LowPriority0 {
         monadThrowable.raiseError(e)
     }
   }
-
   implicit def scalazTryFinally[F[_], A, B](implicit
       monadError: MonadThrowable[F]
   ): TryFinally[A, F[B], F[A], F[Unit]] =
@@ -172,36 +172,39 @@ object scalaz extends scalaz.LowPriority0 {
       }
     }
 
-  implicit def scalazTryCatch[F[_], A, B](implicit
+  given [F[_], A, B](using
       monadError: MonadThrowable[F]
-  ): TryCatch[A, F[B], F[A]] =
-    new TryCatch[A, F[B], F[A]] {
-      def tryCatch(
-          block: F[A] !! A,
-          catcher: Catcher[F[A] !! A],
-          outerSuccessHandler: A => F[B]
-      ): F[B] = {
-        import monadError.monadErrorSyntax._
-        catchNativeException(block)
-          .handleError { e =>
-            def recover(): F[A] = {
-              (try {
-                catcher.lift(e)
-              } catch {
-                case NonFatal(extractorException) =>
-                  return monadError.raiseError(extractorException)
-              }) match {
-                case None =>
-                  monadError.raiseError(e)
-                case Some(recovered) =>
-                  catchNativeException(recovered)
-              }
-            }
-            recover()
-          }
-          .flatMap(outerSuccessHandler)
-      }
+  ): keywords.TryCatch.DslComposer[F[B], A, F[A]] =
+    keywords.TryCatch.DslComposer {
+      [BlockKeyword, CaseKeyword] =>
+        (
+            blockDsl: Dsl.Searching[BlockKeyword, F[A], A],
+            caseDsl: Dsl.Searching[CaseKeyword, F[A], A]
+        ) ?=>
+          Dsl.Composed[keywords.TryCatch[BlockKeyword, CaseKeyword], F[B], A] {
+            case (keywords.TryCatch(block, catcher), outerSuccessHandler) =>
+              import monadError.monadErrorSyntax._
+              summon[Dsl.Run[BlockKeyword, F[A], A]](block)
+                .handleError { e =>
+                  def recover(): F[A] = {
+                    (try {
+                      catcher.lift(e)
+                    } catch {
+                      case NonFatal(extractorException) =>
+                        return monadError.raiseError(extractorException)
+                    }) match {
+                      case None =>
+                        monadError.raiseError(e)
+                      case Some(recovered) =>
+                        summon[Dsl.Run[CaseKeyword, F[A], A]](recovered)
+                    }
+                  }
+                  recover()
+                }
+                .flatMap(outerSuccessHandler)
+        }
     }
+
   private[scalaz] trait LowPriority0:
     /** The [[Dsl]] instance that converts a keyword to the monad domain type
       * then flatMap. This instance helps when the keyword supports a domain `D`