effect 2.0.0-next.52 → 2.0.0-next.53

package/src/internal/core.ts

@@ -35,7 +35,7 @@ import type * as MetricLabel from "../MetricLabel"
 import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate, Refinement } from "../Predicate"
+import { hasProperty, isObject, type Predicate, type Refinement } from "../Predicate"
 import * as ReadonlyArray from "../ReadonlyArray"
 import type * as Request from "../Request"
 import type * as BlockedRequests from "../RequestBlock"
@@ -44,6 +44,7 @@ import type * as RuntimeFlags from "../RuntimeFlags"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch"
 import type * as Scope from "../Scope"
 import type * as Tracer from "../Tracer"
+import { effectVariance } from "./Effectable"
 
 // -----------------------------------------------------------------------------
 // Effect
@@ -66,8 +67,7 @@ export interface EffectError<E> {
 }
 
 /** @internal */
-export const isEffectError = (u: unknown): u is EffectError<unknown> =>
-  typeof u === "object" && u != null && EffectErrorTypeId in u
+export const isEffectError = (u: unknown): u is EffectError<unknown> => hasProperty(u, EffectErrorTypeId)
 
 /** @internal */
 export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
@@ -253,13 +253,6 @@ class EffectPrimitiveSuccess {
   }
 }
 
-/** @internal */
-const effectVariance = {
-  _R: (_: never) => _,
-  _E: (_: never) => _,
-  _A: (_: never) => _
-}
-
 /** @internal */
 export type Op<Tag extends string, Body = {}> = Effect.Effect<never, never, never> & Body & {
   readonly _op: Tag
@@ -379,8 +372,7 @@ export interface WithRuntime extends
 export interface Yield extends Op<OpCodes.OP_YIELD> {}
 
 /** @internal */
-export const isEffect = (u: unknown): u is Effect.Effect<unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && EffectTypeId in u
+export const isEffect = (u: unknown): u is Effect.Effect<unknown, unknown, unknown> => hasProperty(u, EffectTypeId)
 
 /* @internal */
 export const withFiberRuntime = <R, E, A>(
@@ -610,7 +602,7 @@ const originalSymbol = Symbol.for("effect/OriginalAnnotation")
 
 /* @internal */
 export const originalInstance = <E>(obj: E): E => {
-  if (typeof obj === "object" && obj !== null && originalSymbol in obj) {
+  if (hasProperty(obj, originalSymbol)) {
     // @ts-expect-error
     return obj[originalSymbol]
   }
@@ -641,7 +633,7 @@ const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E => {
 
 /* @internal */
 export const die = (defect: unknown): Effect.Effect<never, never, never> =>
-  typeof defect === "object" && defect !== null && !(spanSymbol in defect) ?
+  isObject(defect) && !(spanSymbol in defect) ?
     withFiberRuntime((fiber) => failCause(internalCause.die(capture(defect, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.die(defect))
 
@@ -668,7 +660,7 @@ export const exit = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, ne
 
 /* @internal */
 export const fail = <E>(error: E): Effect.Effect<never, E, never> =>
-  typeof error === "object" && error !== null && !(spanSymbol in error) ?
+  isObject(error) && !(spanSymbol in error) ?
     withFiberRuntime((fiber) => failCause(internalCause.fail(capture(error, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.fail(error))
 
@@ -1634,7 +1626,7 @@ export class RequestResolverImpl<R, A> implements RequestResolver.RequestResolve
 
 /** @internal */
 export const isRequestResolver = (u: unknown): u is RequestResolver.RequestResolver<unknown, unknown> =>
-  typeof u === "object" && u != null && RequestResolverTypeId in u
+  hasProperty(u, RequestResolverTypeId)
 
 // end
 

package/src/internal/dataSource.ts

@@ -193,7 +193,7 @@ export const fromFunction = <A extends Request.Request<never, any>>(
 
 /** @internal */
 export const fromFunctionBatched = <A extends Request.Request<never, any>>(
-  f: (chunk: Array<A>) => Array<Request.Request.Success<A>>
+  f: (chunk: Array<A>) => Iterable<Request.Request.Success<A>>
 ): RequestResolver.RequestResolver<A> =>
   makeBatched((as: Array<A>) =>
     Effect.forEach(
@@ -204,7 +204,7 @@ export const fromFunctionBatched = <A extends Request.Request<never, any>>(
   ).identified("FromFunctionBatched", f)
 
 /** @internal */
-export const fromFunctionEffect = <R, A extends Request.Request<any, any>>(
+export const fromEffect = <R, A extends Request.Request<any, any>>(
   f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
 ): RequestResolver.RequestResolver<A, R> =>
   makeBatched((requests: Array<A>) =>
@@ -213,7 +213,51 @@ export const fromFunctionEffect = <R, A extends Request.Request<any, any>>(
       (a) => Effect.flatMap(Effect.exit(f(a)), (e) => complete(a, e as any)),
       { concurrency: "unbounded", discard: true }
     )
-  ).identified("FromFunctionEffect", f)
+  ).identified("FromEffect", f)
+
+/** @internal */
+export const fromEffectTagged = <
+  A extends Request.Request<any, any> & {
+    readonly _tag: string
+  }
+>() =>
+<
+  Fns extends {
+    readonly [Tag in A["_tag"]]: [Extract<A, { readonly _tag: Tag }>] extends [infer Req] ?
+      Req extends Request.Request<infer ReqE, infer ReqA> ?
+        (requests: Array<Req>) => Effect.Effect<any, ReqE, Iterable<ReqA>>
+      : never
+      : never
+  }
+>(
+  fns: Fns
+): RequestResolver.RequestResolver<
+  A,
+  ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer R, infer _E, infer _A> ? R : never
+> =>
+  makeBatched<any, A>((requests: Array<A>) => {
+    const grouped: Record<string, Array<A>> = {}
+    const tags: Array<A["_tag"]> = []
+    for (let i = 0, len = requests.length; i < len; i++) {
+      if (tags.includes(requests[i]._tag)) {
+        grouped[requests[i]._tag].push(requests[i])
+      } else {
+        grouped[requests[i]._tag] = [requests[i]]
+        tags.push(requests[i]._tag)
+      }
+    }
+    return Effect.forEach(
+      tags,
+      (tag) =>
+        Effect.matchCauseEffect((fns[tag] as any)(grouped[tag]) as Effect.Effect<unknown, unknown, Array<any>>, {
+          onFailure: (cause) =>
+            Effect.forEach(grouped[tag], (req) => complete(req, core.exitFail(cause) as any), { discard: true }),
+          onSuccess: (res) =>
+            Effect.forEach(grouped[tag], (req, i) => complete(req, core.exitSucceed(res[i]) as any), { discard: true })
+        }),
+      { concurrency: "unbounded", discard: true }
+    )
+  }).identified("FromEffectTagged", fns)
 
 /** @internal */
 export const never: RequestResolver.RequestResolver<never> = make(() => Effect.never).identified("Never")

package/src/internal/effect/circular.ts

@@ -296,7 +296,7 @@ class Key<A> implements Equal.Equal {
   [memoKeySymbol] = memoKeySymbol
   constructor(readonly a: A, readonly eq?: Equivalence<A>) {}
   [Equal.symbol](that: Equal.Equal) {
-    if (typeof that === "object" && that !== null && memoKeySymbol in that) {
+    if (Predicate.hasProperty(that, memoKeySymbol)) {
       if (this.eq) {
         return this.eq(this.a, (that as unknown as Key<A>).a)
       } else {

package/src/internal/fiber.ts

@@ -15,6 +15,7 @@ import * as number from "../Number"
 import * as Option from "../Option"
 import * as order from "../Order"
 import { pipeArguments } from "../Pipeable"
+import { hasProperty } from "../Predicate"
 
 /** @internal */
 const FiberSymbolKey = "effect/Fiber"
@@ -58,8 +59,7 @@ export const Order: order.Order<Fiber.RuntimeFiber<unknown, unknown>> = pipe(
 )
 
 /** @internal */
-export const isFiber = (u: unknown): u is Fiber.Fiber<unknown, unknown> =>
-  typeof u === "object" && u != null && FiberTypeId in u
+export const isFiber = (u: unknown): u is Fiber.Fiber<unknown, unknown> => hasProperty(u, FiberTypeId)
 
 /** @internal */
 export const isRuntimeFiber = <E, A>(self: Fiber.Fiber<E, A>): self is Fiber.RuntimeFiber<E, A> =>

package/src/internal/fiberId.ts

@@ -7,6 +7,7 @@ import * as HashSet from "../HashSet"
 import { NodeInspectSymbol, toJSON, toString } from "../Inspectable"
 import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
+import { hasProperty } from "../Predicate"
 
 /** @internal */
 const FiberIdSymbolKey = "effect/FiberId"
@@ -151,9 +152,7 @@ export const composite = (left: FiberId.FiberId, right: FiberId.FiberId): FiberI
 }
 
 /** @internal */
-export const isFiberId = (self: unknown): self is FiberId.FiberId => {
-  return typeof self === "object" && self != null && FiberIdTypeId in self
-}
+export const isFiberId = (self: unknown): self is FiberId.FiberId => hasProperty(self, FiberIdTypeId)
 
 /** @internal */
 export const isNone = (self: FiberId.FiberId): self is FiberId.None => {

package/src/internal/fiberRuntime.ts

@@ -6,6 +6,7 @@ import type { ConfigProvider } from "../ConfigProvider"
 import * as Context from "../Context"
 import * as Deferred from "../Deferred"
 import type * as Effect from "../Effect"
+import { EffectTypeId } from "../Effectable"
 import type * as Either from "../Either"
 import * as ExecutionStrategy from "../ExecutionStrategy"
 import type * as Exit from "../Exit"
@@ -64,6 +65,7 @@ import type * as Scope from "../Scope"
 import type * as Supervisor from "../Supervisor"
 import type * as Tracer from "../Tracer"
 import type { Concurrency } from "../Types"
+import { moduleVersion } from "./version"
 
 /** @internal */
 export const fiberStarted = metric.counter("effect_fiber_started")
@@ -1283,20 +1285,25 @@ export class FiberRuntime<E, A> implements Fiber.RuntimeFiber<E, A> {
         }
       }
       try {
-        if (!("_op" in cur)) {
+        if (!("_op" in cur) || !((cur as core.Primitive)._op in this)) {
           console.log(cur)
-        }
-        if (!((cur as core.Primitive)._op in this)) {
-          if (typeof cur === "function") {
-            console.log((cur as any)())
-          }
           // @ts-expect-error
           absurd(cur)
         }
+
         // @ts-expect-error
         cur = this._tracer.context(
-          // @ts-expect-error
-          () => this[(cur as core.Primitive)._op](cur as core.Primitive),
+          () => {
+            if (moduleVersion !== (cur as core.Primitive)[EffectTypeId]._V) {
+              return core.dieMessage(
+                `Cannot execute an Effect versioned ${
+                  (cur as core.Primitive)[EffectTypeId]._V
+                } with a Runtime of version ${moduleVersion}`
+              )
+            }
+            // @ts-expect-error
+            return this[(cur as core.Primitive)._op](cur as core.Primitive)
+          },
           this
         )
       } catch (e) {

package/src/internal/fiberStatus.ts

@@ -3,6 +3,7 @@ import type { FiberId } from "../FiberId"
 import type * as FiberStatus from "../FiberStatus"
 import { pipe } from "../Function"
 import * as Hash from "../Hash"
+import { hasProperty } from "../Predicate"
 import type { RuntimeFlags } from "../RuntimeFlags"
 
 const FiberStatusSymbolKey = "effect/FiberStatus"
@@ -105,8 +106,7 @@ export const suspended = (
 ): FiberStatus.FiberStatus => new Suspended(runtimeFlags, blockingOn)
 
 /** @internal */
-export const isFiberStatus = (u: unknown): u is FiberStatus.FiberStatus =>
-  typeof u === "object" && u != null && FiberStatusTypeId in u
+export const isFiberStatus = (u: unknown): u is FiberStatus.FiberStatus => hasProperty(u, FiberStatusTypeId)
 
 /** @internal */
 export const isDone = (self: FiberStatus.FiberStatus): self is FiberStatus.Done => self._tag === OP_DONE

package/src/internal/groupBy.ts

@@ -8,7 +8,7 @@ import { dual, pipe } from "../Function"
 import type * as GroupBy from "../GroupBy"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate } from "../Predicate"
+import { hasProperty, type Predicate } from "../Predicate"
 import * as Queue from "../Queue"
 import * as Ref from "../Ref"
 import type * as Stream from "../Stream"
@@ -37,7 +37,7 @@ const groupByVariance = {
 
 /** @internal */
 export const isGroupBy = (u: unknown): u is GroupBy.GroupBy<unknown, unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && GroupByTypeId in u
+  hasProperty(u, GroupByTypeId)
 
 /** @internal */
 export const evaluate = dual<

package/src/internal/layer.ts

@@ -19,6 +19,7 @@ import * as runtime from "../internal/runtime"
 import * as synchronized from "../internal/synchronizedRef"
 import type * as Layer from "../Layer"
 import { pipeArguments } from "../Pipeable"
+import { hasProperty } from "../Predicate"
 import type * as Runtime from "../Runtime"
 import type * as Schedule from "../Schedule"
 import * as ScheduleDecision from "../ScheduleDecision"
@@ -155,9 +156,7 @@ export interface ZipWithPar extends
 {}
 
 /** @internal */
-export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown> => {
-  return typeof u === "object" && u != null && LayerTypeId in u
-}
+export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown> => hasProperty(u, LayerTypeId)
 
 /** @internal */
 export const isFresh = <R, E, A>(self: Layer.Layer<R, E, A>): boolean => {

package/src/internal/metric/boundaries.ts

@@ -4,6 +4,7 @@ import { pipe } from "../../Function"
 import * as Hash from "../../Hash"
 import type * as MetricBoundaries from "../../MetricBoundaries"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 import * as ReadonlyArray from "../../ReadonlyArray"
 
 /** @internal */
@@ -33,9 +34,8 @@ class MetricBoundariesImpl implements MetricBoundaries.MetricBoundaries {
 }
 
 /** @internal */
-export const isMetricBoundaries = (u: unknown): u is MetricBoundaries.MetricBoundaries => {
-  return typeof u === "object" && u != null && MetricBoundariesTypeId in u
-}
+export const isMetricBoundaries = (u: unknown): u is MetricBoundaries.MetricBoundaries =>
+  hasProperty(u, MetricBoundariesTypeId)
 
 /** @internal */
 export const fromChunk = (chunk: Chunk.Chunk<number>): MetricBoundaries.MetricBoundaries => {

package/src/internal/metric/key.ts

@@ -12,6 +12,7 @@ import type * as MetricKeyType from "../../MetricKeyType"
 import type * as MetricLabel from "../../MetricLabel"
 import * as Option from "../../Option"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 
 /** @internal */
 const MetricKeySymbolKey = "effect/MetricKey"
@@ -57,7 +58,7 @@ class MetricKeyImpl<Type extends MetricKeyType.MetricKeyType<any, any>> implemen
 
 /** @internal */
 export const isMetricKey = (u: unknown): u is MetricKey.MetricKey<MetricKeyType.MetricKeyType<unknown, unknown>> =>
-  typeof u === "object" && u != null && MetricKeyTypeId in u
+  hasProperty(u, MetricKeyTypeId)
 
 /** @internal */
 export const counter: {

package/src/internal/metric/keyType.ts

@@ -6,6 +6,7 @@ import * as Hash from "../../Hash"
 import type * as MetricBoundaries from "../../MetricBoundaries"
 import type * as MetricKeyType from "../../MetricKeyType"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 
 /** @internal */
 const MetricKeyTypeSymbolKey = "effect/MetricKeyType"
@@ -218,46 +219,40 @@ export const summary = (
  * @since 2.0.0
  * @category refinements
  */
-export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> => {
-  return typeof u === "object" && u != null && MetricKeyTypeTypeId in u
-}
+export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
+  hasProperty(u, MetricKeyTypeTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> => {
-  return typeof u === "object" && u != null && CounterKeyTypeTypeId in u
-}
+export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
+  hasProperty(u, CounterKeyTypeTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency => {
-  return typeof u === "object" && u != null && FrequencyKeyTypeTypeId in u
-}
+export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
+  hasProperty(u, FrequencyKeyTypeTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> => {
-  return typeof u === "object" && u != null && GaugeKeyTypeTypeId in u
-}
+export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
+  hasProperty(u, GaugeKeyTypeTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram => {
-  return typeof u === "object" && u != null && HistogramKeyTypeTypeId in u
-}
+export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
+  hasProperty(u, HistogramKeyTypeTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary => {
-  return typeof u === "object" && u != null && SummaryKeyTypeTypeId in u
-}
+export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
+  hasProperty(u, SummaryKeyTypeTypeId)

package/src/internal/metric/label.ts

@@ -3,6 +3,7 @@ import { pipe } from "../../Function"
 import * as Hash from "../../Hash"
 import type * as MetricLabel from "../../MetricLabel"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 
 /** @internal */
 const MetricLabelSymbolKey = "effect/MetricLabel"
@@ -39,6 +40,4 @@ export const make = (key: string, value: string): MetricLabel.MetricLabel => {
 }
 
 /** @internal */
-export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => {
-  return typeof u === "object" && u != null && MetricLabelTypeId in u
-}
+export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => hasProperty(u, MetricLabelTypeId)

package/src/internal/metric/state.ts

@@ -6,6 +6,7 @@ import type * as HashMap from "../../HashMap"
 import type * as MetricState from "../../MetricState"
 import type * as Option from "../../Option"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 
 /** @internal */
 const MetricStateSymbolKey = "effect/MetricState"
@@ -244,43 +245,36 @@ export const summary = (
   )
 
 /** @internal */
-export const isMetricState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> => {
-  return typeof u === "object" && u != null && MetricStateTypeId in u
-}
+export const isMetricState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
+  hasProperty(u, MetricStateTypeId)
 
 /** @internal */
-export const isCounterState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> => {
-  return typeof u === "object" && u != null && CounterStateTypeId in u
-}
+export const isCounterState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
+  hasProperty(u, CounterStateTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isFrequencyState = (u: unknown): u is MetricState.MetricState.Frequency => {
-  return typeof u === "object" && u != null && FrequencyStateTypeId in u
-}
+export const isFrequencyState = (u: unknown): u is MetricState.MetricState.Frequency =>
+  hasProperty(u, FrequencyStateTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isGaugeState = (u: unknown): u is MetricState.MetricState.Gauge<number | bigint> => {
-  return typeof u === "object" && u != null && GaugeStateTypeId in u
-}
+export const isGaugeState = (u: unknown): u is MetricState.MetricState.Gauge<number | bigint> =>
+  hasProperty(u, GaugeStateTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isHistogramState = (u: unknown): u is MetricState.MetricState.Histogram => {
-  return typeof u === "object" && u != null && HistogramStateTypeId in u
-}
+export const isHistogramState = (u: unknown): u is MetricState.MetricState.Histogram =>
+  hasProperty(u, HistogramStateTypeId)
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-export const isSummaryState = (u: unknown): u is MetricState.MetricState.Summary => {
-  return typeof u === "object" && u != null && SummaryStateTypeId in u
-}
+export const isSummaryState = (u: unknown): u is MetricState.MetricState.Summary => hasProperty(u, SummaryStateTypeId)

package/src/internal/pool.ts

@@ -14,6 +14,7 @@ import * as queue from "../internal/queue"
 import * as ref from "../internal/ref"
 import { pipeArguments } from "../Pipeable"
 import type * as Pool from "../Pool"
+import { hasProperty } from "../Predicate"
 import type * as Queue from "../Queue"
 import type * as Ref from "../Ref"
 import type * as Scope from "../Scope"
@@ -456,8 +457,7 @@ const makeWith = <R, E, A, S, R2>(
   )
 
 /** @internal */
-export const isPool = (u: unknown): u is Pool.Pool<unknown, unknown> =>
-  typeof u === "object" && u != null && PoolTypeId in u
+export const isPool = (u: unknown): u is Pool.Pool<unknown, unknown> => hasProperty(u, PoolTypeId)
 
 /** @internal */
 export const make = <R, E, A>(

package/src/internal/queue.ts

@@ -8,6 +8,7 @@ import * as MutableQueue from "../MutableQueue"
 import * as MutableRef from "../MutableRef"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
+import { hasProperty } from "../Predicate"
 import type * as Queue from "../Queue"
 import * as ReadonlyArray from "../ReadonlyArray"
 
@@ -322,12 +323,10 @@ const takeRemainderLoop = <A>(
 export const isQueue = (u: unknown): u is Queue.Queue<unknown> => isEnqueue(u) && isDequeue(u)
 
 /** @internal */
-export const isEnqueue = (u: unknown): u is Queue.Enqueue<unknown> =>
-  typeof u === "object" && u != null && EnqueueTypeId in u
+export const isEnqueue = (u: unknown): u is Queue.Enqueue<unknown> => hasProperty(u, EnqueueTypeId)
 
 /** @internal */
-export const isDequeue = (u: unknown): u is Queue.Dequeue<unknown> =>
-  typeof u === "object" && u != null && DequeueTypeId in u
+export const isDequeue = (u: unknown): u is Queue.Dequeue<unknown> => hasProperty(u, DequeueTypeId)
 
 /** @internal */
 export const bounded = <A>(requestedCapacity: number): Effect.Effect<never, never, Queue.Queue<A>> =>

package/src/internal/request.ts

@@ -2,6 +2,7 @@ import type * as Effect from "../Effect"
 import { dual } from "../Function"
 import * as completedRequestMap from "../internal/completedRequestMap"
 import * as core from "../internal/core"
+import { hasProperty } from "../Predicate"
 import type * as Request from "../Request"
 import * as Data from "./Data"
 
@@ -20,8 +21,7 @@ const requestVariance = {
 }
 
 /** @internal */
-export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> =>
-  typeof u === "object" && u != null && RequestTypeId in u
+export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> => hasProperty(u, RequestTypeId)
 
 /** @internal */
 export const of = <R extends Request.Request<any, any>>(): Request.Request.Constructor<R> => (args) =>

package/src/internal/runtime.ts

@@ -167,7 +167,7 @@ export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure =>
     const head = prettyErrors[0]
     error.name = head.message.split(":")[0]
     error.message = head.message.substring(error.name.length + 2)
-    error.stack = `${error.name}: ${error.message}\n${head.stack}`
+    error.stack = InternalCause.pretty(cause)
   }
   error[FiberFailureId] = FiberFailureId
   error[FiberFailureCauseId] = cause
@@ -187,8 +187,7 @@ export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure =>
 }
 
 /** @internal */
-export const isFiberFailure = (u: unknown): u is Runtime.FiberFailure =>
-  typeof u === "object" && u !== null && FiberFailureId in u
+export const isFiberFailure = (u: unknown): u is Runtime.FiberFailure => Predicate.hasProperty(u, FiberFailureId)
 
 const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | undefined => {
   const op = effect as core.Primitive

package/src/internal/sink.ts

@@ -14,7 +14,7 @@ import * as HashMap from "../HashMap"
 import * as HashSet from "../HashSet"
 import * as Option from "../Option"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate, Refinement } from "../Predicate"
+import { hasProperty, type Predicate, type Refinement } from "../Predicate"
 import * as PubSub from "../PubSub"
 import * as Queue from "../Queue"
 import * as ReadonlyArray from "../ReadonlyArray"
@@ -51,7 +51,7 @@ export class SinkImpl<R, E, In, L, Z> implements Sink.Sink<R, E, In, L, Z> {
 
 /** @internal */
 export const isSink = (u: unknown): u is Sink.Sink<unknown, unknown, unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && SinkTypeId in u
+  hasProperty(u, SinkTypeId)
 
 /** @internal */
 export const suspend = <R, E, In, L, Z>(evaluate: LazyArg<Sink.Sink<R, E, In, L, Z>>): Sink.Sink<R, E, In, L, Z> =>

package/src/internal/stm/core.ts

@@ -21,10 +21,12 @@ import * as TryCommit from "../../internal/stm/stm/tryCommit"
 import * as TxnId from "../../internal/stm/stm/txnId"
 import type * as Option from "../../Option"
 import { pipeArguments } from "../../Pipeable"
+import { hasProperty } from "../../Predicate"
 import type * as Scheduler from "../../Scheduler"
 import type * as STM from "../../STM"
 import { StreamTypeId } from "../../Stream"
 import { ChannelTypeId } from "../core-stream"
+import { effectVariance } from "../Effectable"
 import { SinkTypeId } from "../sink"
 
 /** @internal */
@@ -155,7 +157,7 @@ class STMPrimitive implements STM.STM<any, any, any> {
     return stmVariance
   }
   constructor(readonly i0: Primitive["i0"]) {
-    this[Effect.EffectTypeId] = stmVariance
+    this[Effect.EffectTypeId] = effectVariance
     this[StreamTypeId] = stmVariance
     this[SinkTypeId] = stmVariance
     this[ChannelTypeId] = stmVariance
@@ -175,8 +177,7 @@ class STMPrimitive implements STM.STM<any, any, any> {
 }
 
 /** @internal */
-export const isSTM = (u: unknown): u is STM.STM<unknown, unknown, unknown> =>
-  typeof u === "object" && u != null && STMTypeId in u
+export const isSTM = (u: unknown): u is STM.STM<unknown, unknown, unknown> => hasProperty(u, STMTypeId)
 
 /** @internal */
 export const commit = <R, E, A>(self: STM.STM<R, E, A>): Effect.Effect<R, E, A> =>

package/src/internal/stm/stm/stmState.ts

@@ -5,6 +5,7 @@ import * as Hash from "../../../Hash"
 import * as OpCodes from "../../../internal/stm/opCodes/stmState"
 import * as TExitOpCodes from "../../../internal/stm/opCodes/tExit"
 import type * as TExit from "../../../internal/stm/stm/tExit"
+import { hasProperty } from "../../../Predicate"
 
 /** @internal */
 const STMStateSymbolKey = "effect/STM/State"
@@ -38,9 +39,7 @@ export interface Running extends Equal.Equal {
 }
 
 /** @internal */
-export const isSTMState = (u: unknown): u is STMState<unknown, unknown> => {
-  return typeof u === "object" && u != null && STMStateTypeId in u
-}
+export const isSTMState = (u: unknown): u is STMState<unknown, unknown> => hasProperty(u, STMStateTypeId)
 
 /** @internal */
 export const isRunning = <E, A>(self: STMState<E, A>): self is Running => {