Add isMutableHashMap and isMutableHashSet (#1767)

gcanti · web-flow · commit 58217d318a7d · 2026-03-17T11:47:56.000+01:00
diff --git a/.changeset/odd-boats-think.md b/.changeset/odd-boats-think.md
@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Add `isMutableHashMap` and `isMutableHashSet`, and align nominal guard implementations and tests across collections and transactional data types.
diff --git a/packages/effect/src/Effect.ts b/packages/effect/src/Effect.ts
@@ -372,7 +372,7 @@ export declare namespace Yieldable {
  * @since 2.0.0
  * @category Guards
  */
-export const isEffect = (u: unknown): u is Effect<any, any, any> => typeof u === "object" && u !== null && TypeId in u
+export const isEffect: (u: unknown) => u is Effect<any, any, any> = core.isEffect
 
 /**
  * Iterator interface for Effect generators, enabling Effect values to work with generator functions.
@@ -13270,7 +13270,7 @@ export const annotateLogs = dual<
     ): Effect<A, E, R>
   }
 >(
-  (args) => core.isEffect(args[0]),
+  (args) => isEffect(args[0]),
   <A, E, R>(
     effect: Effect<A, E, R>,
     ...args: [Record<string, unknown>] | [key: string, value: unknown]
diff --git a/packages/effect/src/FileSystem.ts b/packages/effect/src/FileSystem.ts
@@ -43,6 +43,7 @@ import { pipe } from "./Function.ts"
 import * as Layer from "./Layer.ts"
 import * as Option from "./Option.ts"
 import { badArgument, type PlatformError, systemError } from "./PlatformError.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Pull from "./Pull.ts"
 import type { Scope } from "./Scope.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -999,7 +1000,7 @@ export const FileTypeId = "~effect/platform/FileSystem/File"
  * @since 4.0.0
  * @category File
  */
-export const isFile = (u: unknown): u is File => typeof u === "object" && u !== null && FileTypeId in u
+export const isFile = (u: unknown): u is File => hasProperty(u, FileTypeId)
 
 /**
  * Interface representing an open file handle.
diff --git a/packages/effect/src/Graph.ts b/packages/effect/src/Graph.ts
@@ -11,6 +11,7 @@ import { NodeInspectSymbol } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type { Mutable } from "./Types.ts"
 
 const TypeId = "~effect/collections/Graph"
@@ -222,7 +223,7 @@ const missingNode = (node: number) => new GraphError({ message: `Node ${node} do
  * @since 4.0.0
  * @category Guards
  */
-export const isGraph = (u: unknown): u is Graph<unknown, unknown> => typeof u === "object" && u !== null && TypeId in u
+export const isGraph = (u: unknown): u is Graph<unknown, unknown> => hasProperty(u, TypeId)
 
 /**
  * Creates a directed graph, optionally with initial mutations.
diff --git a/packages/effect/src/MutableHashMap.ts b/packages/effect/src/MutableHashMap.ts
@@ -33,6 +33,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashMap"
 
@@ -71,6 +72,14 @@ export interface MutableHashMap<out K, out V> extends Iterable<[K, V]>, Pipeable
   readonly buckets: Map<number, NonEmptyArray<K>>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashMap`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashMap = <K, V>(value: unknown): value is MutableHashMap<K, V> => hasProperty(value, TypeId)
+
 const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "backing" | "buckets" | "bucketsSize"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<[unknown, unknown]> {
diff --git a/packages/effect/src/MutableHashSet.ts b/packages/effect/src/MutableHashSet.ts
@@ -30,6 +30,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashSet"
 
@@ -68,6 +69,14 @@ export interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectabl
   readonly keyMap: MutableHashMap.MutableHashMap<V, boolean>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashSet`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashSet = <V>(value: unknown): value is MutableHashSet<V> => hasProperty(value, TypeId)
+
 const MutableHashSetProto: Omit<MutableHashSet<unknown>, "keyMap"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashSet<unknown>): Iterator<unknown> {
diff --git a/packages/effect/src/Resource.ts b/packages/effect/src/Resource.ts
@@ -6,6 +6,7 @@ import * as Exit from "./Exit.ts"
 import { identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Schedule from "./Schedule.ts"
 import type * as Scope from "./Scope.ts"
 import * as ScopedRef from "./ScopedRef.ts"
@@ -32,7 +33,7 @@ export interface Resource<in out A, in out E = never> extends Pipeable {
  */
 export const isResource: (u: unknown) => u is Resource<unknown, unknown> = (
   u: unknown
-): u is Resource<unknown, unknown> => typeof u === "object" && u !== null && TypeId in u
+): u is Resource<unknown, unknown> => hasProperty(u, TypeId)
 
 const Proto = {
   ...PipeInspectableProto,
diff --git a/packages/effect/src/SubscriptionRef.ts b/packages/effect/src/SubscriptionRef.ts
@@ -6,6 +6,7 @@ import { dual, identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import * as PubSub from "./PubSub.ts"
 import * as Semaphore from "./Semaphore.ts"
 import * as Stream from "./Stream.ts"
@@ -29,7 +30,7 @@ export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>,
  */
 export const isSubscriptionRef: (u: unknown) => u is SubscriptionRef<unknown> = (
   u: unknown
-): u is SubscriptionRef<unknown> => typeof u === "object" && u != null && TypeId in u
+): u is SubscriptionRef<unknown> => hasProperty(u, TypeId)
 
 /**
  * The `SynchronizedRef` namespace containing type definitions and utilities.
diff --git a/packages/effect/src/TxDeferred.ts b/packages/effect/src/TxDeferred.ts
@@ -13,6 +13,7 @@ import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type { Result } from "./Result.ts"
 import * as Res from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
@@ -270,5 +271,4 @@ export const fail: {
  * @since 4.0.0
  * @category guards
  */
-export const isTxDeferred = (u: unknown): u is TxDeferred<unknown, unknown> =>
-  typeof u === "object" && u !== null && TypeId in u
+export const isTxDeferred = (u: unknown): u is TxDeferred<unknown, unknown> => hasProperty(u, TypeId)
diff --git a/packages/effect/src/TxHashMap.ts b/packages/effect/src/TxHashMap.ts
@@ -11,6 +11,7 @@ import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type { Result } from "./Result.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -1158,7 +1159,7 @@ export const setMany: {
  * @category guards
  */
 export const isTxHashMap = <K, V>(value: unknown): value is TxHashMap<K, V> => {
-  return typeof value === "object" && value !== null && TypeId in value
+  return hasProperty(value, TypeId)
 }
 
 /**
diff --git a/packages/effect/src/TxHashSet.ts b/packages/effect/src/TxHashSet.ts
@@ -10,7 +10,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate, Refinement } from "./Predicate.ts"
+import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 import type { NoInfer } from "./Types.ts"
 
@@ -286,7 +286,7 @@ export const fromHashSet = <V>(hashSet: HashSet.HashSet<V>): Effect.Effect<TxHas
  * @since 2.0.0
  * @category guards
  */
-export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => typeof u === "object" && u !== null && TypeId in u
+export const isTxHashSet = (u: unknown): u is TxHashSet<unknown> => hasProperty(u, TypeId)
 
 /**
  * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.
diff --git a/packages/effect/src/TxPriorityQueue.ts b/packages/effect/src/TxPriorityQueue.ts
@@ -16,7 +16,7 @@ import * as O from "./Option.ts"
 import type { Order } from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
-import type { Predicate } from "./Predicate.ts"
+import { hasProperty, type Predicate } from "./Predicate.ts"
 import * as TxRef from "./TxRef.ts"
 
 const TypeId = "~effect/transactions/TxPriorityQueue"
@@ -532,5 +532,4 @@ export const toArray = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, ne
  * @since 4.0.0
  * @category guards
  */
-export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> =>
-  typeof u === "object" && u !== null && TypeId in u
+export const isTxPriorityQueue = (u: unknown): u is TxPriorityQueue<unknown> => hasProperty(u, TypeId)
diff --git a/packages/effect/src/TxSemaphore.ts b/packages/effect/src/TxSemaphore.ts
@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -584,4 +585,4 @@ export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never,
  * @since 4.0.0
  * @category guards
  */
-export const isTxSemaphore = (u: unknown): u is TxSemaphore => typeof u === "object" && u !== null && TypeId in u
+export const isTxSemaphore = (u: unknown): u is TxSemaphore => hasProperty(u, TypeId)
diff --git a/packages/effect/test/Effect.test.ts b/packages/effect/test/Effect.test.ts
@@ -27,6 +27,11 @@ import { assertCauseFail } from "./utils/assert.ts"
 class ATag extends ServiceMap.Service<ATag, "A">()("ATag") {}
 
 describe("Effect", () => {
+  it("isEffect", () => {
+    assert.isTrue(Effect.isEffect(Effect.succeed(0)))
+    assert.isFalse(Effect.isEffect([0]))
+  })
+
   describe("structural compare", () => {
     it("should pass structural comparison", () => {
       assert.deepEqual(Effect.succeed(0), Effect.succeed(0))
diff --git a/packages/effect/test/MutableHashMap.test.ts b/packages/effect/test/MutableHashMap.test.ts
@@ -35,6 +35,11 @@ function value(c: number, d: number): Value {
 }
 
 describe("MutableHashMap", () => {
+  it("isMutableHashMap", () => {
+    assertTrue(HM.isMutableHashMap(HM.make([0, "a"], [1, "b"])))
+    assertFalse(HM.isMutableHashMap(new Map([[0, "a"]])))
+  })
+
   it("toString", () => {
     const map = HM.make(
       [0, "a"],
diff --git a/packages/effect/test/MutableHashSet.test.ts b/packages/effect/test/MutableHashSet.test.ts
@@ -0,0 +1,10 @@
+import { describe, it } from "@effect/vitest"
+import { assertFalse, assertTrue } from "@effect/vitest/utils"
+import { MutableHashSet } from "effect"
+
+describe("MutableHashSet", () => {
+  it("isMutableHashSet", () => {
+    assertTrue(MutableHashSet.isMutableHashSet(MutableHashSet.make("a", "b")))
+    assertFalse(MutableHashSet.isMutableHashSet(new Set(["a", "b"])))
+  })
+})
diff --git a/packages/effect/test/Resource.test.ts b/packages/effect/test/Resource.test.ts
@@ -8,6 +8,13 @@ import * as Schedule from "effect/Schedule"
 import * as TestClock from "effect/testing/TestClock"
 
 describe("Resource", () => {
+  it.effect("isResource", () =>
+    Effect.gen(function*() {
+      const resource = yield* Resource.manual(Effect.succeed(0))
+      assert.isTrue(Resource.isResource(resource))
+      assert.isFalse(Resource.isResource(new Set([0])))
+    }))
+
   it.effect("manual", () =>
     Effect.gen(function*() {
       const ref = yield* Ref.make(0)
diff --git a/packages/effect/test/SubscriptionRef.test.ts b/packages/effect/test/SubscriptionRef.test.ts
@@ -2,6 +2,13 @@ import { assert, describe, it } from "@effect/vitest"
 import { Array, Effect, Exit, Fiber, Latch, Number, Pull, Random, Stream, SubscriptionRef } from "effect"
 
 describe("SubscriptionRef", () => {
+  it.effect("isSubscriptionRef", () =>
+    Effect.gen(function*() {
+      const ref = yield* SubscriptionRef.make(0)
+      assert.isTrue(SubscriptionRef.isSubscriptionRef(ref))
+      assert.isFalse(SubscriptionRef.isSubscriptionRef([0]))
+    }))
+
   it.effect("multiple subscribers can receive changes", () =>
     Effect.gen(function*() {
       const ref = yield* SubscriptionRef.make(0)
diff --git a/packages/effect/test/TxDeferred.test.ts b/packages/effect/test/TxDeferred.test.ts
@@ -131,6 +131,7 @@ describe("TxDeferred", () => {
         assert.isFalse(TxDeferred.isTxDeferred({ some: "object" }))
         assert.isFalse(TxDeferred.isTxDeferred(null))
         assert.isFalse(TxDeferred.isTxDeferred(undefined))
+        assert.isFalse(TxDeferred.isTxDeferred([1]))
       })))
   })
 
diff --git a/packages/effect/test/TxPriorityQueue.test.ts b/packages/effect/test/TxPriorityQueue.test.ts
@@ -154,6 +154,7 @@ describe("TxPriorityQueue", () => {
         assert.isTrue(TxPriorityQueue.isTxPriorityQueue(pq))
         assert.isFalse(TxPriorityQueue.isTxPriorityQueue(null))
         assert.isFalse(TxPriorityQueue.isTxPriorityQueue({ some: "object" }))
+        assert.isFalse(TxPriorityQueue.isTxPriorityQueue([1, 2, 3]))
       })))
   })
 
diff --git a/packages/effect/test/TxSemaphore.test.ts b/packages/effect/test/TxSemaphore.test.ts
@@ -230,6 +230,7 @@ describe("TxSemaphore", () => {
         assert.isFalse(TxSemaphore.isTxSemaphore(notSemaphore))
         assert.isFalse(TxSemaphore.isTxSemaphore(null))
         assert.isFalse(TxSemaphore.isTxSemaphore(undefined))
+        assert.isFalse(TxSemaphore.isTxSemaphore([5]))
       })))
   })
 

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"effect": patch
 +---
++
 +Add `isMutableHashMap` and `isMutableHashSet`, and align nominal guard implementations and tests across collections and transactional data types.