Rename most mapK methods to liftTo

Rename `mapK` methods that take a `KindTransformer` to `liftTo`.

Author: NthPortal

build.sbt

@@ -225,8 +225,17 @@ lazy val `core-trace` = crossProject(JVMPlatform, JSPlatform, NativePlatform)
       "org.scodec" %%% "scodec-bits" % ScodecVersion,
       "org.typelevel" %%% "cats-laws" % CatsVersion % Test,
       "org.typelevel" %%% "discipline-munit" % MUnitDisciplineVersion % Test,
-      "org.typelevel" %%% "scalacheck-effect-munit" % MUnitScalaCheckEffectVersion % Test
-    )
+      "org.typelevel" %%% "scalacheck-effect-munit" % MUnitScalaCheckEffectVersion % Test,
+    ),
+    mimaBinaryIssueFilters ++= Seq(
+      // # 1002
+      // all of these classes are private (and not serializable), so this is safe
+      ProblemFilters.exclude[MissingClassProblem]("org.typelevel.otel4s.trace.SpanBuilder$MappedK"),
+      ProblemFilters.exclude[MissingClassProblem]("org.typelevel.otel4s.trace.SpanOps$MappedK"),
+      ProblemFilters.exclude[MissingClassProblem]("org.typelevel.otel4s.trace.Tracer$MappedK"),
+      ProblemFilters.exclude[MissingClassProblem]("org.typelevel.otel4s.trace.TracerBuilder$MappedK"),
+      ProblemFilters.exclude[MissingClassProblem]("org.typelevel.otel4s.trace.TracerProvider$MappedK"),
+    ),
   )
 
 lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)

core/common/src/main/scala/org/typelevel/otel4s/baggage/BaggageManager.scala

@@ -42,7 +42,7 @@ trait BaggageManager[F[_]] {
   /** @return the current scope's `Baggage` */
   def current: F[Baggage]
 
-  @deprecated("BaggageManager no longer extends Local. Use `current` instead", since = "0.13.0")
+  @deprecated("BaggageManager no longer extends Local. Use `current` instead", since = "otel4s 0.13.0")
   final def ask[E2 >: Baggage]: F[E2] = applicative.widen(current)
 
   /** @return
@@ -60,22 +60,22 @@ trait BaggageManager[F[_]] {
   /** Creates a new scope in which a modified version of the current `Baggage` is used. */
   def local[A](modify: Baggage => Baggage)(fa: F[A]): F[A]
 
-  @deprecated("BaggageManager no longer extends Local. Reverse parameter list order", since = "0.13.0")
+  @deprecated("BaggageManager no longer extends Local. Reverse parameter list order", since = "otel4s 0.13.0")
   final def local[A](fa: F[A])(modify: Baggage => Baggage): F[A] =
     local(modify)(fa)
 
   /** Creates a new scope in which the given `Baggage` is used. */
   def scope[A](baggage: Baggage)(fa: F[A]): F[A]
 
-  @deprecated("BaggageManager no longer extends Local. Reverse parameter list order", since = "0.13.0")
+  @deprecated("BaggageManager no longer extends Local. Reverse parameter list order", since = "otel4s 0.13.0")
   final def scope[A](fa: F[A])(baggage: Baggage): F[A] =
     scope(baggage)(fa)
 }
 
 object BaggageManager {
   def apply[F[_]](implicit ev: BaggageManager[F]): BaggageManager[F] = ev
 
-  @deprecated("BaggageManager no longer extends Local", since = "0.13.0")
+  @deprecated("BaggageManager no longer extends Local", since = "otel4s 0.13.0")
   implicit def asExplicitLocal[F[_]](bm: BaggageManager[F]): Local[F, Baggage] =
     new Local[F, Baggage] {
       def applicative: Applicative[F] = bm.applicative

core/common/src/main/scala/org/typelevel/otel4s/meta/InstrumentMeta.scala

@@ -43,8 +43,11 @@ object InstrumentMeta {
 
     /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
       */
-    def mapK[G[_]: Monad](implicit kt: KindTransformer[F, G]): InstrumentMeta.Dynamic[G] =
+    def liftTo[G[_]: Monad](implicit kt: KindTransformer[F, G]): InstrumentMeta.Dynamic[G] =
       mapK(kt.liftK)
+
+    @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+    def mapK[G[_]: Monad](implicit kt: KindTransformer[F, G]): InstrumentMeta.Dynamic[G] = liftTo[G]
   }
 
   object Dynamic {
@@ -93,8 +96,11 @@ object InstrumentMeta {
 
     /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
       */
-    def mapK[G[_]](implicit kt: KindTransformer[F, G]): InstrumentMeta.Static[G] =
+    def liftTo[G[_]](implicit kt: KindTransformer[F, G]): InstrumentMeta.Static[G] =
       mapK(kt.liftK)
+
+    @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+    def mapK[G[_]](implicit kt: KindTransformer[F, G]): InstrumentMeta.Static[G] = liftTo[G]
   }
 
   object Static {

core/trace/src/main/scala/org/typelevel/otel4s/trace/Span.scala

@@ -111,8 +111,11 @@ trait Span[F[_]] extends SpanMacro[F] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  final def mapK[G[_]](implicit kt: KindTransformer[F, G]): Span[G] =
+  final def liftTo[G[_]](implicit kt: KindTransformer[F, G]): Span[G] =
     mapK(kt.liftK)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  final def mapK[G[_]](implicit kt: KindTransformer[F, G]): Span[G] = liftTo[G]
 }
 
 object Span {
@@ -156,8 +159,11 @@ object Span {
 
     /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
       */
-    final def mapK[G[_]](implicit kt: KindTransformer[F, G]): Backend[G] =
+    final def liftTo[G[_]](implicit kt: KindTransformer[F, G]): Backend[G] =
       mapK(kt.liftK)
+
+    @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+    final def mapK[G[_]](implicit kt: KindTransformer[F, G]): Backend[G] = liftTo[G]
   }
 
   object Backend {
@@ -204,7 +210,7 @@ object Span {
         def end(timestamp: FiniteDuration): F[Unit] = unit
       }
 
-    /** Implementation for [[Backend.mapK]]. */
+    /** Implementation for [[Backend.liftTo]]. */
     private class MappedK[F[_], G[_]](backend: Backend[F])(f: F ~> G) extends Backend[G] {
       val meta: InstrumentMeta.Static[G] =
         backend.meta.mapK(f)

core/trace/src/main/scala/org/typelevel/otel4s/trace/SpanBuilder.scala

@@ -52,11 +52,17 @@ trait SpanBuilder[F[_]] extends SpanBuilderMacro[F] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  def mapK[G[_]: MonadCancelThrow](implicit
+  def liftTo[G[_]: MonadCancelThrow](implicit
       F: MonadCancelThrow[F],
       kt: KindTransformer[F, G]
   ): SpanBuilder[G] =
-    new SpanBuilder.MappedK(this)
+    new SpanBuilder.Lifted(this)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  def mapK[G[_]: MonadCancelThrow](implicit
+      F: MonadCancelThrow[F],
+      kt: KindTransformer[F, G]
+  ): SpanBuilder[G] = liftTo[G]
 }
 
 object SpanBuilder {
@@ -248,18 +254,16 @@ object SpanBuilder {
       }
     }
 
-  /** Implementation for [[SpanBuilder.mapK]]. */
-  private class MappedK[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
+  /** Implementation for [[SpanBuilder.liftTo]]. */
+  private class Lifted[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
       builder: SpanBuilder[F]
   )(implicit kt: KindTransformer[F, G])
       extends SpanBuilder[G] {
     val meta: InstrumentMeta.Dynamic[G] =
-      builder.meta.mapK[G]
-
+      builder.meta.liftTo[G]
     def modifyState(f: State => State): SpanBuilder[G] =
-      builder.modifyState(f).mapK[G]
-
+      builder.modifyState(f).liftTo[G]
     def build: SpanOps[G] =
-      builder.build.mapK[G]
+      builder.build.liftTo[G]
   }
 }

core/trace/src/main/scala/org/typelevel/otel4s/trace/SpanOps.scala

@@ -244,11 +244,17 @@ trait SpanOps[F[_]] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  def mapK[G[_]: MonadCancelThrow](implicit
+  def liftTo[G[_]: MonadCancelThrow](implicit
       F: MonadCancelThrow[F],
       kt: KindTransformer[F, G]
   ): SpanOps[G] =
-    new SpanOps.MappedK(this)
+    new SpanOps.Lifted(this)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  def mapK[G[_]: MonadCancelThrow](implicit
+      F: MonadCancelThrow[F],
+      kt: KindTransformer[F, G]
+  ): SpanOps[G] = liftTo[G]
 }
 
 object SpanOps {
@@ -284,8 +290,11 @@ object SpanOps {
 
     /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
       */
-    def mapK[G[_]](implicit kt: KindTransformer[F, G]): Res[G] =
-      Res(span.mapK[G], kt.liftFunctionK(trace))
+    def liftTo[G[_]](implicit kt: KindTransformer[F, G]): Res[G] =
+      Res(span.liftTo[G], kt.liftFunctionK(trace))
+
+    @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+    def mapK[G[_]](implicit kt: KindTransformer[F, G]): Res[G] = liftTo[G]
   }
 
   object Res {
@@ -301,20 +310,17 @@ object SpanOps {
       Some((res.span, res.trace))
   }
 
-  /** Implementation for [[SpanOps.mapK]]. */
-  private class MappedK[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
+  /** Implementation for [[SpanOps.liftTo]]. */
+  private class Lifted[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
       ops: SpanOps[F]
   )(implicit kt: KindTransformer[F, G])
       extends SpanOps[G] {
     def startUnmanaged: G[Span[G]] =
-      kt.liftK(ops.startUnmanaged).map(_.mapK[G])
-
+      kt.liftK(ops.startUnmanaged).map(_.liftTo[G])
     def resource: Resource[G, Res[G]] =
-      ops.resource.mapK(kt.liftK).map(res => res.mapK[G])
-
+      ops.resource.mapK(kt.liftK).map(res => res.liftTo[G])
     def use[A](f: Span[G] => G[A]): G[A] =
       resource.use { res => res.trace(f(res.span)) }
-
     def use_ : G[Unit] = kt.liftK(ops.use_)
   }
 }

core/trace/src/main/scala/org/typelevel/otel4s/trace/Tracer.scala

@@ -199,11 +199,17 @@ trait Tracer[F[_]] extends TracerMacro[F] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  def mapK[G[_]: MonadCancelThrow](implicit
+  def liftTo[G[_]: MonadCancelThrow](implicit
       F: MonadCancelThrow[F],
       kt: KindTransformer[F, G]
   ): Tracer[G] =
-    new Tracer.MappedK(this)
+    new Tracer.Lifted(this)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  def mapK[G[_]: MonadCancelThrow](implicit
+      F: MonadCancelThrow[F],
+      kt: KindTransformer[F, G]
+  ): Tracer[G] = liftTo[G]
 }
 
 object Tracer {
@@ -239,20 +245,20 @@ object Tracer {
         Applicative[F].pure(carrier)
     }
 
-  /** Implementation for [[Tracer.mapK]]. */
-  private class MappedK[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
+  /** Implementation for [[Tracer.liftTo]]. */
+  private class Lifted[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
       tracer: Tracer[F]
   )(implicit kt: KindTransformer[F, G])
       extends Tracer[G] {
-    val meta: InstrumentMeta.Dynamic[G] = tracer.meta.mapK[G]
+    val meta: InstrumentMeta.Dynamic[G] = tracer.meta.liftTo[G]
     def currentSpanContext: G[Option[SpanContext]] =
       kt.liftK(tracer.currentSpanContext)
     def currentSpanOrNoop: G[Span[G]] =
-      kt.liftK(tracer.currentSpanOrNoop.map(_.mapK[G]))
+      kt.liftK(tracer.currentSpanOrNoop.map(_.liftTo[G]))
     def currentSpanOrThrow: G[Span[G]] =
-      kt.liftK(tracer.currentSpanOrThrow.map(_.mapK[G]))
+      kt.liftK(tracer.currentSpanOrThrow.map(_.liftTo[G]))
     def spanBuilder(name: String): SpanBuilder[G] =
-      tracer.spanBuilder(name).mapK[G]
+      tracer.spanBuilder(name).liftTo[G]
     def childScope[A](parent: SpanContext)(ga: G[A]): G[A] =
       kt.limitedMapK(ga)(new (F ~> F) {
         def apply[B](fb: F[B]): F[B] = tracer.childScope(parent)(fb)

core/trace/src/main/scala/org/typelevel/otel4s/trace/TracerBuilder.scala

@@ -43,11 +43,17 @@ trait TracerBuilder[F[_]] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  def mapK[G[_]: MonadCancelThrow](implicit
+  def liftTo[G[_]: MonadCancelThrow](implicit
       F: MonadCancelThrow[F],
       kt: KindTransformer[F, G]
   ): TracerBuilder[G] =
-    new TracerBuilder.MappedK(this)
+    new TracerBuilder.Lifted(this)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  def mapK[G[_]: MonadCancelThrow](implicit
+      F: MonadCancelThrow[F],
+      kt: KindTransformer[F, G]
+  ): TracerBuilder[G] = liftTo[G]
 }
 
 object TracerBuilder {
@@ -66,16 +72,16 @@ object TracerBuilder {
       def get: F[Tracer[F]] = F.pure(Tracer.noop)
     }
 
-  private class MappedK[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
+  private class Lifted[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
       builder: TracerBuilder[F]
   )(implicit
       kt: KindTransformer[F, G]
   ) extends TracerBuilder[G] {
     def withVersion(version: String): TracerBuilder[G] =
-      new MappedK(builder.withVersion(version))
+      new Lifted(builder.withVersion(version))
     def withSchemaUrl(schemaUrl: String): TracerBuilder[G] =
-      new MappedK(builder.withSchemaUrl(schemaUrl))
+      new Lifted(builder.withSchemaUrl(schemaUrl))
     def get: G[Tracer[G]] =
-      kt.liftK(builder.get.map(_.mapK[G]))
+      kt.liftK(builder.get.map(_.liftTo[G]))
   }
 }

core/trace/src/main/scala/org/typelevel/otel4s/trace/TracerProvider.scala

@@ -60,11 +60,17 @@ trait TracerProvider[F[_]] {
 
   /** Modify the context `F` using an implicit [[KindTransformer]] from `F` to `G`.
     */
-  def mapK[G[_]: MonadCancelThrow](implicit
+  def liftTo[G[_]: MonadCancelThrow](implicit
       F: MonadCancelThrow[F],
       kt: KindTransformer[F, G]
   ): TracerProvider[G] =
-    new TracerProvider.MappedK(this)
+    new TracerProvider.Lifted(this)
+
+  @deprecated("use `liftTo` instead", since = "otel4s 0.13.1")
+  def mapK[G[_]: MonadCancelThrow](implicit
+      F: MonadCancelThrow[F],
+      kt: KindTransformer[F, G]
+  ): TracerProvider[G] = liftTo[G]
 }
 
 object TracerProvider {
@@ -86,13 +92,13 @@ object TracerProvider {
         "TracerProvider.Noop"
     }
 
-  private class MappedK[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
+  private class Lifted[F[_]: MonadCancelThrow, G[_]: MonadCancelThrow](
       provider: TracerProvider[F]
   )(implicit kt: KindTransformer[F, G])
       extends TracerProvider[G] {
     override def get(name: String): G[Tracer[G]] =
-      kt.liftK(provider.get(name).map(_.mapK[G]))
+      kt.liftK(provider.get(name).map(_.liftTo[G]))
     def tracer(name: String): TracerBuilder[G] =
-      provider.tracer(name).mapK[G]
+      provider.tracer(name).liftTo[G]
   }
 }