Add two new combinators: cedeMap and intercede

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

@@ -497,6 +497,20 @@ sealed abstract class IO[+A] private () extends IOPlatform[A] {
    */
   def map[B](f: A => B): IO[B] = IO.Map(this, f, Tracing.calculateTracingEvent(f))
 
+  /**
+   * Functor map, but causes a reschedule before and after `f`. For more information, checkout
+   * `cede` in the companion object.
+   */
+  def cedeMap[B](f: A => B): IO[B] =
+    (this <* IO.cede).map(a => f(a)).guarantee(IO.cede)
+
+  /**
+   * Causes a reschedule before and after `fa`. For more information, checkout `cede` in the
+   * companion object.
+   */
+  def intercede: IO[A] =
+    IO.cede *> this.guarantee(IO.cede)
+
   /**
    * Applies rate limiting to this `IO` based on provided backpressure semantics.
    *

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

@@ -282,6 +282,18 @@ trait GenSpawn[F[_], E] extends MonadCancel[F, E] with Unique[F] {
    */
   def cede: F[Unit]
 
+  /**
+   * Functor map, but causes a reschedule before and after `f`
+   */
+  def cedeMap[A, B](fa: F[A])(f: A => B): F[B] =
+    (fa <* cede).map(a => f(a)).guarantee(cede)
+
+  /**
+   * Causes a reschedule before and after `fa`
+   */
+  def intercede[A](fa: F[A]): F[A] =
+    cede *> fa.guarantee(cede)
+
   /**
    * A low-level primitive for racing the evaluation of two fibers that returns the [[Outcome]]
    * of the winner and the [[Fiber]] of the loser. The winner of the race is considered to be

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

@@ -59,4 +59,10 @@ final class GenSpawnOps[F[_], A, E] private[syntax] (private val wrapped: F[A])
       implicit F: GenSpawn[F, E]
   ): F[(Outcome[F, E, A], Outcome[F, E, B])] =
     F.bothOutcome(wrapped, another)
+
+  def cedeMap[B](f: A => B)(implicit F: GenSpawn[F, E]): F[B] =
+    F.cedeMap(wrapped)(f)
+
+  def intercede(implicit F: GenSpawn[F, E]): F[A] =
+    F.intercede(wrapped)
 }

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

@@ -104,7 +104,8 @@ class SyntaxSpec extends Specification {
     }
   }
 
-  def genSpawnSyntax[F[_], A, B, E](target: F[A], another: F[B])(implicit F: GenSpawn[F, E]) = {
+  def genSpawnSyntax[F[_], A, B, E](target: F[A], another: F[B], f: A => B)(
+      implicit F: GenSpawn[F, E]) = {
     import syntax.spawn._
 
     GenSpawn[F]: F.type
@@ -139,6 +140,16 @@ class SyntaxSpec extends Specification {
       val result = target.bothOutcome(another)
       result: F[(Outcome[F, E, A], Outcome[F, E, B])]
     }
+
+    {
+      val result = target.cedeMap(f)
+      result: F[B]
+    }
+
+    {
+      val result = target.intercede
+      result: F[A]
+    }
   }
 
   def spawnForwarder[F[_]: Spawn] =