Feature/prop

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

@@ -40,7 +40,7 @@ import cats.data.Ior
 import cats.effect.instances.spawn
 import cats.effect.kernel.CancelScope
 import cats.effect.kernel.GenTemporal.handleDuration
-import cats.effect.std.{Backpressure, Console, Env, Supervisor, UUIDGen}
+import cats.effect.std.{Backpressure, Console, Env, Supervisor, SystemProperties, UUIDGen}
 import cats.effect.tracing.{Tracing, TracingEvent}
 import cats.effect.unsafe.IORuntime
 import cats.syntax._
@@ -2159,6 +2159,8 @@ object IO extends IOCompanionPlatform with IOLowPriorityImplicits with TuplePara
 
   implicit val envForIO: Env[IO] = Env.make
 
+  implicit val systemPropertiesForIO: SystemProperties[IO] = SystemProperties.make
+
   // This is cached as a val to save allocations, but it uses ops from the Async
   // instance which is also cached as a val, and therefore needs to appear
   // later in the file

std/shared/src/main/scala/cats/effect/std/MapRef.scala

@@ -21,6 +21,7 @@ import cats.data._
 import cats.effect.kernel._
 import cats.syntax.all._
 
+import java.util.Hashtable
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -34,12 +35,15 @@ import java.util.concurrent.ConcurrentHashMap
  * concurrent updates may be executed independently to each other, as long as their keys belong
  * to different shards.
  */
-trait MapRef[F[_], K, V] extends Function1[K, Ref[F, V]] {
+trait MapRef[F[_], K, V] extends Function1[K, Ref[F, V]] { outer =>
 
   /**
    * Access the reference for this Key
    */
   def apply(k: K): Ref[F, V]
+
+  def mapK[G[_]](f: F ~> G)(implicit G: Functor[G]): MapRef[G, K, V] =
+    outer(_).mapK(f)
 }
 
 object MapRef extends MapRefCompanionPlatform {
@@ -123,7 +127,7 @@ object MapRef extends MapRefCompanionPlatform {
       ref: Ref[F, Map[K, V]]): MapRef[F, K, Option[V]] =
     k => Ref.lens(ref)(_.get(k), m => _.fold(m - k)(v => m + (k -> v)))
 
-  private class ConcurrentHashMapImpl[F[_], K, V](chm: ConcurrentHashMap[K, V], sync: Sync[F])
+  private class JavaMapImpl[F[_], K, V](chm: java.util.Map[K, V], sync: Sync[F])
       extends MapRef[F, K, Option[V]] {
     private implicit def syncF: Sync[F] = sync
 
@@ -241,7 +245,11 @@ object MapRef extends MapRefCompanionPlatform {
    */
   def fromConcurrentHashMap[F[_]: Sync, K, V](
       map: ConcurrentHashMap[K, V]): MapRef[F, K, Option[V]] =
-    new ConcurrentHashMapImpl[F, K, V](map, Sync[F])
+    new JavaMapImpl[F, K, V](map, Sync[F])
+
+  private[std] def fromHashtable[F[_]: Sync, K, V](
+      map: Hashtable[K, V]): MapRef[F, K, Option[V]] =
+    new JavaMapImpl[F, K, V](map, Sync[F])
 
   /**
    * This allocates mutable memory, so it has to be inside F. The way to use things like this is

std/shared/src/main/scala/cats/effect/std/SystemProperties.scala

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2020-2024 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.std
+
+import cats.{~>, Applicative, Functor}
+import cats.data.{EitherT, IorT, Kleisli, OptionT, ReaderWriterStateT, StateT, WriterT}
+import cats.effect.kernel.{Ref, Sync}
+import cats.kernel.Monoid
+
+import java.util.Hashtable
+
+trait SystemProperties[F[_]] extends MapRef[F, String, Option[String]] { outer =>
+
+  def apply(key: String): Ref[F, Option[String]]
+
+  override def mapK[G[_]](f: F ~> G)(implicit G: Functor[G]): SystemProperties[G] =
+    outer(_).mapK(f)
+}
+
+object SystemProperties {
+
+  /**
+   * Summoner method for `SystemProperties` instances.
+   */
+  def apply[F[_]](implicit ev: SystemProperties[F]): ev.type = ev
+
+  /**
+   * Constructs a `SystemProperties` instance for `F` data types that are
+   * [[cats.effect.kernel.Sync]].
+   */
+  def make[F[_]](implicit F: Sync[F]): SystemProperties[F] = new SyncSystemProperties[F]
+
+  /**
+   * [[Prop]] instance built for `cats.data.EitherT` values initialized with any `F` data type
+   * that also implements `Prop`.
+   */
+  implicit def catsEitherTSystemProperties[F[_]: SystemProperties: Functor, L]
+      : SystemProperties[EitherT[F, L, *]] =
+    SystemProperties[F].mapK(EitherT.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.Kleisli` values initialized with any `F` data type
+   * that also implements `Prop`.
+   */
+  implicit def catsKleisliSystemProperties[F[_]: Functor: SystemProperties, R]
+      : SystemProperties[Kleisli[F, R, *]] =
+    SystemProperties[F].mapK(Kleisli.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.OptionT` values initialized with any `F` data type
+   * that also implements `Prop`.
+   */
+  implicit def catsOptionTSystemProperties[F[_]: SystemProperties: Functor]
+      : SystemProperties[OptionT[F, *]] =
+    SystemProperties[F].mapK(OptionT.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.StateT` values initialized with any `F` data type
+   * that also implements `Prop`.
+   */
+  implicit def catsStateTSystemProperties[F[_]: SystemProperties: Applicative, S]
+      : SystemProperties[StateT[F, S, *]] =
+    SystemProperties[F].mapK(StateT.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.WriterT` values initialized with any `F` data type
+   * that also implements `Prop`.
+   */
+  implicit def catsWriterTSystemProperties[
+      F[_]: SystemProperties: Applicative,
+      L: Monoid
+  ]: SystemProperties[WriterT[F, L, *]] =
+    SystemProperties[F].mapK(WriterT.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.IorT` values initialized with any `F` data type that
+   * also implements `Prop`.
+   */
+  implicit def catsIorTSystemProperties[F[_]: SystemProperties: Functor, L]
+      : SystemProperties[IorT[F, L, *]] =
+    SystemProperties[F].mapK(IorT.liftK)
+
+  /**
+   * [[Prop]] instance built for `cats.data.ReaderWriterStateT` values initialized with any `F`
+   * data type that also implements `Prop`.
+   */
+  implicit def catsReaderWriterStateTSystemProperties[
+      F[_]: SystemProperties: Applicative,
+      E,
+      L: Monoid,
+      S
+  ]: SystemProperties[ReaderWriterStateT[F, E, L, S, *]] =
+    SystemProperties[F].mapK(ReaderWriterStateT.liftK)
+
+  private[std] final class SyncSystemProperties[F[_]](implicit F: Sync[F])
+      extends SystemProperties[F] {
+
+    private[this] val underlying =
+      MapRef.fromHashtable(System.getProperties().asInstanceOf[Hashtable[String, String]])
+
+    def apply(key: String) = underlying(key)
+  }
+}

tests/shared/src/test/scala/cats/effect/std/SystemPropertiesSpec.scala

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020-2024 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
+package std
+
+import org.typelevel.scalaccompat.annotation._
+
+class SystemPropertiesSpec extends BaseSpec {
+
+  "SystemProperties" should {
+    "retrieve a property just set" in real {
+      Random.javaUtilConcurrentThreadLocalRandom[IO].nextString(12).flatMap { key =>
+        SystemProperties[IO].set(key, "bar") *>
+          SystemProperties[IO].get(key).flatMap(x => IO(x mustEqual Some("bar")))
+      }
+    }
+    "return none for a non-existent property" in real {
+      SystemProperties[IO].get("MADE_THIS_UP").flatMap(x => IO(x must beNone))
+    }
+    "unset" in real {
+      Random.javaUtilConcurrentThreadLocalRandom[IO].nextString(12).flatMap { key =>
+        SystemProperties[IO].set(key, "bar") *> SystemProperties[IO].unset(key) *>
+          SystemProperties[IO].get(key).flatMap(x => IO(x must beNone))
+      }
+    }
+    "retrieve the system properties" in real {
+      for {
+        _ <- SystemProperties[IO].set("some property", "the value")
+        props <- SystemProperties[IO].entries
+        expected <- IO {
+          import scala.collection.JavaConverters._
+          Map.empty ++ System.getProperties.asScala
+        }: @nowarn213("cat=deprecation") @nowarn3("cat=deprecation")
+        assertion <- IO(props mustEqual expected)
+      } yield assertion
+    }
+  }
+}