Merge pull request #1677 from patseev/series/3.x

core/shared/src/main/scala/cats/effect/IO.scala

@@ -159,6 +159,9 @@ sealed abstract class IO[+A] private () extends IOPlatform[A] {
       case Left(value) => IO.pure(value)
     }
 
+  def timed: IO[(FiniteDuration, A)] =
+    Clock[IO].timed(this)
+
   def product[B](that: IO[B]): IO[(A, B)] =
     flatMap(a => that.map(b => (a, b)))
 

core/shared/src/main/scala/cats/effect/syntax/package.scala

@@ -26,4 +26,5 @@ package object syntax {
   object temporal extends kernel.syntax.GenTemporalSyntax
   object async extends kernel.syntax.AsyncSyntax
   object resource extends kernel.syntax.ResourceSyntax
+  object clock extends kernel.syntax.ClockSyntax
 }

kernel/shared/src/main/scala/cats/effect/kernel/Clock.scala

@@ -33,6 +33,14 @@ trait Clock[F[_]] extends ClockPlatform[F] {
 
   // lawless (unfortunately), but meant to represent current (when sequenced) system time
   def realTime: F[FiniteDuration]
+
+  /**
+   * Returns an effect that completes with the result of the source together
+   * with the duration that it took to complete.
+   */
+  def timed[A](fa: F[A]): F[(FiniteDuration, A)] =
+    applicative.map3(monotonic, fa, monotonic)((startTime, a, endTime) =>
+      (endTime.minus(startTime), a))
 }
 
 object Clock {

kernel/shared/src/main/scala/cats/effect/kernel/GenTemporal.scala

@@ -71,7 +71,6 @@ trait GenTemporal[F[_], E] extends GenConcurrent[F, E] with Clock[F] {
     val timeoutException = raiseError[A](ev(new TimeoutException(duration.toString)))
     timeoutTo(fa, duration, timeoutException)
   }
-
 }
 
 object GenTemporal {

kernel/shared/src/main/scala/cats/effect/kernel/syntax/AllSyntax.scala

@@ -23,3 +23,4 @@ trait AllSyntax
     with GenConcurrentSyntax
     with AsyncSyntax
     with ResourceSyntax
+    with ClockSyntax

kernel/shared/src/main/scala/cats/effect/kernel/syntax/ClockSyntax.scala

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2020-2021 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cats.effect.kernel.syntax
+
+import cats.effect.kernel.Clock
+
+import scala.concurrent.duration.FiniteDuration
+
+trait ClockSyntax {
+  implicit def clockOps[F[_], A](wrapped: F[A]): ClockOps[F, A] =
+    new ClockOps(wrapped)
+}
+
+final class ClockOps[F[_], A] private[syntax] (private val wrapped: F[A]) extends AnyVal {
+
+  def timed(implicit F: Clock[F]): F[(FiniteDuration, A)] =
+    F.timed(wrapped)
+}

kernel/shared/src/main/scala/cats/effect/kernel/syntax/package.scala

@@ -26,4 +26,5 @@ package object syntax {
   object temporal extends GenTemporalSyntax
   object async extends AsyncSyntax
   object resource extends ResourceSyntax
+  object clock extends ClockSyntax
 }

kernel/shared/src/test/scala/cats/effect/kernel/SyntaxSpec.scala

@@ -195,4 +195,15 @@ class SyntaxSpec extends Specification {
       result: Resource[F, A]
     }
   }
+
+  def clockSyntax[F[_], A](target: F[A])(implicit F: Clock[F]) = {
+    import syntax.clock._
+
+    Clock[F]: F.type
+
+    {
+      val result = target.timed
+      result: F[(FiniteDuration, A)]
+    }
+  }
 }