Merge pull request #122 from ChristopherDavenport/mapKImplementations

MapK implementations

Author: ChristopherDavenport

.gitignore

@@ -8,5 +8,6 @@ tags
 
 .bloop
 .metals
+project/metals.sbt
 
 .vscode

build.sbt

@@ -37,7 +37,7 @@ lazy val commonSettings = Seq(
   organization := "io.chrisdavenport",
 
   scalaVersion := "2.13.0",
-  crossScalaVersions := Seq(scalaVersion.value, "2.12.9"),
+  crossScalaVersions := Seq(scalaVersion.value, "2.12.10"),
 
   scalacOptions in (Compile, doc) ++= Seq(
       "-groups",

core/src/main/scala/io/chrisdavenport/epimetheus/Counter.scala

@@ -55,6 +55,8 @@ sealed abstract class Counter[F[_]]{
    *
    */
   def incBy(d: Double): F[Unit]
+
+  def mapK[G[_]](fk: F ~> G): Counter[G] = new Counter.MapKCounter[F, G](this, fk)
 }
 
 /**
@@ -99,7 +101,7 @@ object Counter {
   ): F[UnlabelledCounter[F, A]] = for {
       c <- Sync[F].delay(JCounter.build().name(name.getName).help(help).labelNames(labels.map(_.getLabel):_*))
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledCounter[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledCounterImpl[F, A](out, f.andThen(_.unsized))
 
   private final class NoLabelsCounter[F[_]: Sync] private[Counter] (private[Counter] val underlying: JCounter) extends Counter[F] {
     override def get: F[Double] = Sync[F].delay(underlying.get)
@@ -115,25 +117,44 @@ object Counter {
     def incBy(d: Double): F[Unit] = Sync[F].delay(underlying.inc(d))
   }
 
+  private final class MapKCounter[F[_], G[_]](private[Counter] val base: Counter[F], fk: F ~> G) extends Counter[G]{
+    def get: G[Double] = fk(base.get)
+    def inc: G[Unit] = fk(base.inc)
+    def incBy(d: Double): G[Unit] = fk(base.incBy(d))
+  }
+
   /**
    * Generic Unlabeled Counter
    *
    * It is necessary to apply a value of type `A` to this
    * counter to be able to take any measurements.
    */
-  final class UnlabelledCounter[F[_]: Sync, A] private[Counter](
+  sealed trait UnlabelledCounter[F[_], A]{
+    def label(a: A): Counter[F]
+    def mapK[G[_]](fk: F ~> G): UnlabelledCounter[G, A] = new MapKUnlabelledCounter[F, G, A](this, fk)
+  }
+
+  private final class UnlabelledCounterImpl[F[_]: Sync, A] private[Counter](
     private[Counter] val underlying: JCounter,
     private val f: A => IndexedSeq[String]
-  ) {
+  ) extends UnlabelledCounter[F, A]{
     def label(a: A): Counter[F] =
       new LabelledCounter(underlying.labels(f(a):_*))
   }
 
+  private final class MapKUnlabelledCounter[F[_], G[_], A](private[Counter] val base: UnlabelledCounter[F, A], fk: F ~> G) extends UnlabelledCounter[G, A]{
+    def label(a: A): Counter[G] = base.label(a).mapK(fk)
+  }
+
   object Unsafe {
-    def asJavaUnlabelled[F[_], A](c: UnlabelledCounter[F, A]): JCounter = c.underlying
+    def asJavaUnlabelled[F[_], A](c: UnlabelledCounter[F, A]): JCounter = c match {
+      case m: MapKUnlabelledCounter[_, _, _] => asJavaUnlabelled(m.base)
+      case m: UnlabelledCounterImpl[_, _] => m.underlying
+    }
     def asJava[F[_]: ApplicativeError[?[_], Throwable]](c: Counter[F]): F[JCounter] = c match {
       case _: LabelledCounter[F] => ApplicativeError[F, Throwable].raiseError(new IllegalArgumentException("Cannot Get Underlying Parent with Labels Applied"))
       case n: NoLabelsCounter[F] => n.underlying.pure[F]
+      case b: MapKCounter[_, _] =>  asJava(b.base)
     }
   }
 }

core/src/main/scala/io/chrisdavenport/epimetheus/Gauge.scala

@@ -69,6 +69,8 @@ sealed abstract class Gauge[F[_]]{
   def incBy(d: Double): F[Unit]
 
   def set(d: Double): F[Unit]
+
+  def mapK[G[_]](fk: F ~> G): Gauge[G] = new Gauge.MapKGauge[F, G](this, fk)
 }
 
 /**
@@ -128,7 +130,7 @@ object Gauge {
   ): F[UnlabelledGauge[F, A]] = for {
       c <- Sync[F].delay(JGauge.build().name(name.getName).help(help).labelNames(labels.map(_.getLabel):_*))
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledGauge[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledGaugeImpl[F, A](out, f.andThen(_.unsized))
 
 
   private final class NoLabelsGauge[F[_]: Sync] private[Gauge] (
@@ -159,26 +161,52 @@ object Gauge {
     def set(d: Double): F[Unit] = Sync[F].delay(underlying.set(d))
   }
 
+  private final class MapKGauge[F[_], G[_]](private[Gauge] val base: Gauge[F], fk: F ~> G) extends Gauge[G]{
+    def get: G[Double] = fk(base.get)
+
+    def dec: G[Unit] = fk(base.dec)
+    def decBy(d: Double): G[Unit] = fk(base.decBy(d))
+
+    def inc: G[Unit] = fk(base.inc)
+    def incBy(d: Double): G[Unit] = fk(base.incBy(d))
+
+    def set(d: Double): G[Unit] = fk(base.set(d))
+  }
+
 
+  sealed trait UnlabelledGauge[F[_], A]{
+    def label(a: A): Gauge[F]
+    def mapK[G[_]](fk: F ~> G): UnlabelledGauge[G, A] = new MapKUnlabelledGauge[F, G, A](this, fk)
+  }
 
   /**
    * Generic Unlabeled Gauge
    *
    * It is necessary to apply a value of type `A` to this
    * gauge to be able to take any measurements.
    */
-  final class UnlabelledGauge[F[_]: Sync, A] private[epimetheus](
+  final private class UnlabelledGaugeImpl[F[_]: Sync, A] private[epimetheus](
     private[Gauge] val underlying: JGauge,
     private val f: A => IndexedSeq[String]
-  ) {
+  ) extends UnlabelledGauge[F, A] {
     def label(a: A): Gauge[F] =
       new LabelledGauge[F](underlying.labels(f(a):_*))
   }
+
+  final private class MapKUnlabelledGauge[F[_], G[_], A](private[Gauge] val base: UnlabelledGauge[F, A], fk: F ~> G) extends UnlabelledGauge[G, A]{
+    def label(a: A): Gauge[G] = base.label(a).mapK(fk)
+  }
+
+
   object Unsafe {
-    def asJavaUnlabelled[F[_], A](g: UnlabelledGauge[F, A]): JGauge = g.underlying
+    def asJavaUnlabelled[F[_], A](g: UnlabelledGauge[F, A]): JGauge = g match {
+      case x: UnlabelledGaugeImpl[_, _] => x.underlying
+      case x: MapKUnlabelledGauge[_, _, _] => asJavaUnlabelled(x.base)
+    }
     def asJava[F[_]: ApplicativeError[?[_], Throwable]](c: Gauge[F]): F[JGauge] = c match {
       case _: LabelledGauge[F] => ApplicativeError[F, Throwable].raiseError(new IllegalArgumentException("Cannot Get Underlying Parent with Labels Applied"))
       case n: NoLabelsGauge[F] => n.underlying.pure[F]
+      case m: MapKGauge[_, _] => asJava(m.base)
     }
   }
 }

core/src/main/scala/io/chrisdavenport/epimetheus/Histogram.scala

@@ -7,6 +7,8 @@ import cats.implicits._
 import io.prometheus.client.{Histogram => JHistogram}
 import scala.concurrent.duration._
 import shapeless._
+import io.chrisdavenport.epimetheus.Histogram.UnlabelledHistogramImpl
+import io.chrisdavenport.epimetheus.Histogram.MapKUnlabelledHistogram
 
 /**
  * Histogram metric, to track distributions of events.
@@ -26,6 +28,8 @@ sealed abstract class Histogram[F[_]]{
    */
   def observe(d: Double): F[Unit]
 
+  def mapK[G[_]](fk: F ~> G): Histogram[G] = new Histogram.MapKHistogram[F, G](this, fk)
+
 }
 
 /**
@@ -203,7 +207,7 @@ object Histogram {
       .buckets(buckets:_*)
     )
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledHistogram[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledHistogramImpl[F, A](out, f.andThen(_.unsized))
 
   def labelledLinearBuckets[F[_]: Sync, A, N <: Nat](
     cr: CollectorRegistry[F],
@@ -223,7 +227,7 @@ object Histogram {
       .linearBuckets(start, factor, count)
     )
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledHistogram[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledHistogramImpl[F, A](out, f.andThen(_.unsized))
 
   def labelledExponentialBuckets[F[_]: Sync, A, N <: Nat](
     cr: CollectorRegistry[F],
@@ -243,7 +247,7 @@ object Histogram {
       .exponentialBuckets(start, factor, count)
     )
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledHistogram[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledHistogramImpl[F, A](out, f.andThen(_.unsized))
 
   private final class NoLabelsHistogram[F[_]: Sync] private[Histogram] (
     private[Histogram] val underlying: JHistogram
@@ -258,26 +262,42 @@ object Histogram {
     def observe(d: Double): F[Unit] = Sync[F].delay(underlying.observe(d))
   }
 
+  private final class MapKHistogram[F[_], G[_]](private[Histogram] val base: Histogram[F], fk: F ~> G) extends Histogram[G]{
+    def observe(d: Double): G[Unit] = fk(base.observe(d))
+  }
+
   /**
    * Generic UnlabelledHistorgram
    *
    * It is necessary to apply a value of type `A` to this
    * histogram to be able to take any measurements.
    */
-  final class UnlabelledHistogram[F[_]: Sync, A] private[Histogram] (
+  sealed trait UnlabelledHistogram[F[_], A]{
+    def label(a: A): Histogram[F]
+    def mapK[G[_]](fk: F ~> G): UnlabelledHistogram[G, A] = new MapKUnlabelledHistogram[F, G, A](this, fk)
+  }
+
+  final private class UnlabelledHistogramImpl[F[_]: Sync, A] private[Histogram] (
     private[Histogram] val underlying: JHistogram,
     private val f: A => IndexedSeq[String]
-  ) {
+  ) extends UnlabelledHistogram[F, A]{
     def label(a: A): Histogram[F] =
       new LabelledHistogram[F](underlying.labels(f(a):_*))
   }
 
+  final private class MapKUnlabelledHistogram[F[_], G[_], A](private[Histogram] val base: UnlabelledHistogram[F, A], fk: F ~> G) extends UnlabelledHistogram[G, A]{
+    def label(a: A): Histogram[G] = base.label(a).mapK(fk)
+  }
+
   object Unsafe {
-    def asJavaUnlabelled[F[_], A](h: UnlabelledHistogram[F, A]): JHistogram =
-      h.underlying
+    def asJavaUnlabelled[F[_], A](h: UnlabelledHistogram[F, A]): JHistogram = h match {
+      case h: UnlabelledHistogramImpl[_, _] => h.underlying
+      case h: MapKUnlabelledHistogram[_, _, _] => asJavaUnlabelled(h.base)
+    }
     def asJava[F[_]: ApplicativeError[?[_], Throwable]](c: Histogram[F]): F[JHistogram] = c match {
       case _: LabelledHistogram[F] => ApplicativeError[F, Throwable].raiseError(new IllegalArgumentException("Cannot Get Underlying Parent with Labels Applied"))
       case n: NoLabelsHistogram[F] => n.underlying.pure[F]
+      case h: MapKHistogram[_, _] => asJava(h.base)
     }
   }
 

core/src/main/scala/io/chrisdavenport/epimetheus/Summary.scala

@@ -32,6 +32,8 @@ sealed abstract class Summary[F[_]]{
    * @param d The observation to persist
    */
   def observe(d: Double): F[Unit]
+
+  def mapK[G[_]](fk: F ~> G): Summary[G] = new Summary.MapKSummary[F, G](this, fk)
 }
 
 
@@ -215,7 +217,7 @@ object Summary {
     )
     c <- Sync[F].delay(quantiles.foldLeft(c1){ case (c, q) => c.quantile(q.quantile, q.error)})
     out <- Sync[F].delay(c.register(CollectorRegistry.Unsafe.asJava(cr)))
-  } yield new UnlabelledSummary[F, A](out, f.andThen(_.unsized))
+  } yield new UnlabelledSummaryImpl[F, A](out, f.andThen(_.unsized))
 
   final private class NoLabelsSummary[F[_]: Sync] private[Summary] (
     private[Summary] val underlying: JSummary
@@ -228,19 +230,30 @@ object Summary {
     def observe(d: Double): F[Unit] = Sync[F].delay(underlying.observe(d))
   }
 
+  final private class MapKSummary[F[_], G[_]](private[Summary] val base: Summary[F], fk: F ~> G) extends Summary[G]{
+    def observe(d: Double): G[Unit] = fk(base.observe(d))
+  }
+
   /**
    * Generic Unlabeled Summary
    *
    * Apply a label to be able to measure events.
    */
-  final class UnlabelledSummary[F[_]: Sync, A] private[epimetheus](
+  sealed trait UnlabelledSummary[F[_], A]{
+    def label(a: A): Summary[F]
+    def mapK[G[_]](fk: F ~> G): UnlabelledSummary[G, A] = new MapKUnlabelledSummary[F,G, A](this, fk)
+  }
+  final private class UnlabelledSummaryImpl[F[_]: Sync, A] private[epimetheus](
     private[Summary] val underlying: JSummary,
     private val f: A => IndexedSeq[String]
-  ) {
+  ) extends UnlabelledSummary[F,A]{
     def label(a: A): Summary[F] =
       new LabelledSummary[F](underlying.labels(f(a):_*))
   }
 
+  final private class MapKUnlabelledSummary[F[_], G[_], A](private[Summary] val base: UnlabelledSummary[F,A], fk: F ~> G) extends UnlabelledSummary[G, A]{
+    def label(a: A): Summary[G] = base.label(a).mapK(fk)
+  }
   /**
    * The percentile and tolerated error to be observed
    *
@@ -292,11 +305,14 @@ object Summary {
   }
 
   object Unsafe {
-    def asJavaUnlabelled[F[_], A](g: UnlabelledSummary[F, A]): JSummary =
-      g.underlying
+    def asJavaUnlabelled[F[_], A](g: UnlabelledSummary[F, A]): JSummary = g match {
+      case a: UnlabelledSummaryImpl[_, _] => a.underlying
+      case a: MapKUnlabelledSummary[_, _, _] => asJavaUnlabelled(a.base)
+    }
     def asJava[F[_]: ApplicativeError[?[_], Throwable]](c: Summary[F]): F[JSummary] = c match {
       case _: LabelledSummary[F] => ApplicativeError[F, Throwable].raiseError(new IllegalArgumentException("Cannot Get Underlying Parent with Labels Applied"))
       case n: NoLabelsSummary[F] => n.underlying.pure[F]
+      case b: MapKSummary[_, _] => asJava(b.base)
     }
   }
 }