Rename retryingOnAllErrorsMtl -> retryingOnAllMtlErrors. Update docs

build.sbt

@@ -163,6 +163,8 @@ val root = project
     coreJS,
     alleycatsJVM,
     alleycatsJS,
+    mtlJVM,
+    mtlJS,
     docs
   )
   .settings(commonSettings)

modules/docs/src/main/mdoc/docs/mtl-combinators.md

@@ -28,11 +28,11 @@ MTL retry works independently from `retry.retryingOnSomeErrors`. The operations
 `retry.mtl.retryingOnSomeErrors` evaluating retry exclusively on errors produced by `ApplicativeHandle`.
 Thus errors produced by `MonadError` are not being taken into account and retry is not triggered.
 
-If you want to retry in case of any error, just chain the methods:  
+If you want to retry in case of any error, you can chain the methods:
 ```scala
 fa
   .retryingOnAllErrors(policy, onError = retry.noop[F, Throwable])
-  .retryingOnAllErrorsMtl[AppError](policy, onError = retry.noop[F, AppError])
+  .retryingOnAllMtlErrors[AppError](policy, onError = retry.noop[F, AppError])
 ```
 
 ## `retryingOnSomeErrors`
@@ -94,7 +94,7 @@ retry.mtl
 
 ## `retryingOnAllErrors`
 
-This is useful when you are working with a `ApplicatieHandle[M, E]` and you want to
+This is useful when you are working with a `ApplicativeHandle[M, E]` and you want to
 retry on all errors.
 
 The API (modulo some type-inference trickery) looks like this:
@@ -164,13 +164,13 @@ class Service[F[_]: Timer](client: util.FlakyHttpClient)(implicit F: Sync[F], AH
 
   // evaluates retry exclusively on errors produced by ApplicativeHandle.
   def findCoolCatGifRetryMtl(policy: RetryPolicy[F]): F[String] =
-    findCoolCatGif.retryingOnAllErrorsMtl[AppError](policy, logMtlError)
+    findCoolCatGif.retryingOnAllMtlErrors[AppError](policy, logMtlError)
 
   // evaluates retry on errors produced by MonadError and ApplicativeHandle
   def findCoolCatGifRetryAll(policy: RetryPolicy[F]): F[String] =
     findCoolCatGif
       .retryingOnAllErrors(policy, logError)
-      .retryingOnAllErrorsMtl[AppError](policy, logMtlError)
+      .retryingOnAllMtlErrors[AppError](policy, logMtlError)
 
   private def findCoolCatGif: F[String] =
     for {

modules/mtl/shared/src/main/scala/retry/mtl/syntax/retry.scala

@@ -15,7 +15,7 @@ final class RetryingMtlErrorOps[M[_], A](action: => M[A])(
     implicit M: Monad[M]
 ) {
 
-  def retryingOnAllErrorsMtl[E](
+  def retryingOnAllMtlErrors[E](
       policy: RetryPolicy[M],
       onError: (E, RetryDetails) => M[Unit]
   )(implicit S: Sleep[M], AH: ApplicativeHandle[M, E]): M[A] =
@@ -24,7 +24,7 @@ final class RetryingMtlErrorOps[M[_], A](action: => M[A])(
       onError = onError
     )(action)
 
-  def retryingOnSomeErrorsMtl[E](
+  def retryingOnSomeMtlErrors[E](
       isWorthRetrying: E => Boolean,
       policy: RetryPolicy[M],
       onError: (E, RetryDetails) => M[Unit]

modules/mtl/shared/src/test/scala/retry/mtl/SyntaxSpec.scala

@@ -16,7 +16,7 @@ class SyntaxSpec extends AnyFlatSpec {
   type ErrorOr[A] = Either[Throwable, A]
   type F[A]       = EitherT[ErrorOr, String, A]
 
-  behavior of "retryingOnSomeErrorsMtl"
+  behavior of "retryingOnSomeMtlErrors"
 
   it should "retry until the action succeeds" in new TestContext {
     implicit val sleepForEither: Sleep[F] =
@@ -39,7 +39,7 @@ class SyntaxSpec extends AnyFlatSpec {
 
     val finalResult: F[String] = action
       .retryingOnSomeErrors(_ == error, policy, onError)
-      .retryingOnSomeErrorsMtl[String](_ == "one more time", policy, onMtlError)
+      .retryingOnSomeMtlErrors[String](_ == "one more time", policy, onMtlError)
 
     assert(finalResult.value == Right(Right("yay")))
     assert(attempts == 3)
@@ -68,7 +68,7 @@ class SyntaxSpec extends AnyFlatSpec {
 
     val finalResult: F[String] = action
       .retryingOnSomeErrors(_ == error, policy, onError)
-      .retryingOnSomeErrorsMtl[String](_ == "one more time", policy, onMtlError)
+      .retryingOnSomeMtlErrors[String](_ == "one more time", policy, onMtlError)
 
     assert(finalResult.value == Right(Left("nope")))
     assert(attempts == 3)
@@ -97,7 +97,7 @@ class SyntaxSpec extends AnyFlatSpec {
 
     val finalResult: F[String] = action
       .retryingOnSomeErrors(_ == error, policy, onError)
-      .retryingOnSomeErrorsMtl[String](_ == "one more time", policy, onMtlError)
+      .retryingOnSomeMtlErrors[String](_ == "one more time", policy, onMtlError)
 
     assert(finalResult.value == Right(Left("one more time")))
     assert(attempts == 4)
@@ -112,7 +112,7 @@ class SyntaxSpec extends AnyFlatSpec {
     assert(gaveUp)
   }
 
-  behavior of "retryingOnAllErrorsMtl"
+  behavior of "retryingOnAllMtlErrors"
 
   it should "retry until the action succeeds" in new TestContext {
     implicit val sleepForEither: Sleep[F] =
@@ -135,7 +135,7 @@ class SyntaxSpec extends AnyFlatSpec {
 
     val finalResult: F[String] = action
       .retryingOnAllErrors(policy, onError)
-      .retryingOnAllErrorsMtl[String](policy, onMtlError)
+      .retryingOnAllMtlErrors[String](policy, onMtlError)
 
     assert(finalResult.value == Right(Right("yay")))
     assert(attempts == 3)
@@ -164,7 +164,7 @@ class SyntaxSpec extends AnyFlatSpec {
 
     val finalResult: F[String] = action
       .retryingOnAllErrors(policy, onError)
-      .retryingOnAllErrorsMtl[String](policy, onMtlError)
+      .retryingOnAllMtlErrors[String](policy, onMtlError)
 
     assert(finalResult.value == Right(Left("one more time")))
     assert(attempts == 4)