Add IOLocal#scope

build.sbt

@@ -591,7 +591,8 @@ lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform)
         "cats.effect.NonDaemonThreadLogger.sleepIntervalMillis"),
       ProblemFilters.exclude[DirectMissingMethodProblem](
         "cats.effect.NonDaemonThreadLogger.this"),
-      ProblemFilters.exclude[MissingClassProblem]("cats.effect.NonDaemonThreadLogger$")
+      ProblemFilters.exclude[MissingClassProblem]("cats.effect.NonDaemonThreadLogger$"),
+      ProblemFilters.exclude[ReversedMissingMethodProblem]("cats.effect.IOLocal.scope")
     ) ++ {
       if (tlIsScala3.value) {
         // Scala 3 specific exclusions

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

@@ -16,6 +16,8 @@
 
 package cats.effect
 
+import cats.syntax.functor._
+
 /**
  * [[IOLocal]] provides a handy way of manipulating a context on different scopes.
  *
@@ -188,6 +190,27 @@ sealed trait IOLocal[A] {
    */
   def getAndReset: IO[A]
 
+  /**
+   * Creates a scope with the given value. The original value is restored upon the finalization
+   * of a resource. It means all changes made inside of the resource will not be propagated to
+   * the outside.
+   *
+   * @example
+   *
+   * {{{
+   *   for {
+   *     local <- IOLocal(42)
+   *     _     <- local.get // returns 42
+   *     _     <- local.scope(0).surround(local.getAndSet(1)) // returns 0
+   *     _     <- local.get // returns 42, even though 1 was set inside of the resource
+   *   } yield ()
+   * }}}
+   *
+   * @param value
+   *   the value to make a scope with
+   */
+  def scope(value: A): Resource[IO, Unit]
+
 }
 
 object IOLocal {
@@ -230,6 +253,8 @@ object IOLocal {
         override def getAndReset: IO[A] =
           get <* reset
 
+        override def scope(value: A): Resource[IO, Unit] =
+          Resource.make(getAndSet(value))(p => set(p)).void
       }
     }
 

tests/shared/src/test/scala/cats/effect/IOLocalSpec.scala

@@ -81,6 +81,16 @@ class IOLocalSpec extends BaseSpec {
 
       io must completeAs(0)
     }
+
+    "do not leak internal updates outside of a scope" in ticked { implicit ticker =>
+      val io = for {
+        local <- IOLocal(0)
+        inside <- local.scope(1).surround(local.getAndSet(2))
+        outside <- local.get
+      } yield (inside, outside)
+
+      io must completeAs((1, 0))
+    }
   }
 
 }