effect 3.8.5 → 3.9.0

package/src/internal/managedRuntime.ts

@@ -1,22 +1,28 @@
 import type * as Effect from "../Effect.js"
+import * as Effectable from "../Effectable.js"
 import type { Exit } from "../Exit.js"
 import type * as Fiber from "../Fiber.js"
 import type * as Layer from "../Layer.js"
-import type { ManagedRuntime } from "../ManagedRuntime.js"
+import type * as M from "../ManagedRuntime.js"
 import { pipeArguments } from "../Pipeable.js"
+import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import * as Scope from "../Scope.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as internalLayer from "./layer.js"
+import * as circular from "./managedRuntime/circular.js"
 import * as internalRuntime from "./runtime.js"
 
-interface ManagedRuntimeImpl<R, E> extends ManagedRuntime<R, E> {
+interface ManagedRuntimeImpl<R, E> extends M.ManagedRuntime<R, E> {
   readonly scope: Scope.CloseableScope
   cachedRuntime: Runtime.Runtime<R> | undefined
 }
 
+/** @internal */
+export const isManagedRuntime = (u: unknown): u is M.ManagedRuntime<unknown, unknown> => hasProperty(u, circular.TypeId)
+
 function provide<R, ER, A, E>(
   managed: ManagedRuntimeImpl<R, ER>,
   effect: Effect.Effect<A, E, R>
@@ -32,34 +38,42 @@ function provide<R, ER, A, E>(
   )
 }
 
+const ManagedRuntimeProto = {
+  ...Effectable.CommitPrototype,
+  [circular.TypeId]: circular.TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  commit(this: ManagedRuntimeImpl<unknown, unknown>) {
+    return this.runtimeEffect
+  }
+}
+
 /** @internal */
 export const make = <R, ER>(
   layer: Layer.Layer<R, ER, never>,
   memoMap?: Layer.MemoMap
-): ManagedRuntime<R, ER> => {
+): M.ManagedRuntime<R, ER> => {
   memoMap = memoMap ?? internalLayer.unsafeMakeMemoMap()
   const scope = internalRuntime.unsafeRunSyncEffect(fiberRuntime.scopeMake())
-  const self: ManagedRuntimeImpl<R, ER> = {
+  const runtimeEffect = internalRuntime.unsafeRunSyncEffect(
+    effect.memoize(
+      core.tap(
+        Scope.extend(
+          internalLayer.toRuntimeWithMemoMap(layer, memoMap),
+          scope
+        ),
+        (rt) => {
+          self.cachedRuntime = rt
+        }
+      )
+    )
+  )
+  const self: ManagedRuntimeImpl<R, ER> = Object.assign(Object.create(ManagedRuntimeProto), {
     memoMap,
     scope,
-    runtimeEffect: internalRuntime
-      .unsafeRunSyncEffect(
-        effect.memoize(
-          core.tap(
-            Scope.extend(
-              internalLayer.toRuntimeWithMemoMap(layer, memoMap),
-              scope
-            ),
-            (rt) => {
-              self.cachedRuntime = rt
-            }
-          )
-        )
-      ),
+    runtimeEffect,
     cachedRuntime: undefined,
-    pipe() {
-      return pipeArguments(this, arguments)
-    },
     runtime() {
       return self.cachedRuntime === undefined ?
         internalRuntime.unsafeRunPromiseEffect(self.runtimeEffect) :
@@ -110,6 +124,6 @@ export const make = <R, ER>(
         internalRuntime.unsafeRunPromiseEffect(provide(self, effect), options) :
         internalRuntime.unsafeRunPromise(self.cachedRuntime)(effect, options)
     }
-  }
+  })
   return self
 }

package/src/internal/option.ts

@@ -4,7 +4,7 @@
 
 import * as Equal from "../Equal.js"
 import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as Option from "../Option.js"
 import { hasProperty } from "../Predicate.js"
 import { EffectPrototype } from "./effectable.js"
@@ -16,6 +16,9 @@ const CommonProto = {
   [TypeId]: {
     _A: (_: never) => _
   },
+  [DenoInspectSymbol]<A>(this: Option.Option<A>) {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]<A>(this: Option.Option<A>) {
     return this.toJSON()
   },

package/src/internal/pool.ts

@@ -2,6 +2,7 @@ import type { Cause } from "effect/Cause"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type { Effect, Semaphore } from "../Effect.js"
+import * as Effectable from "../Effectable.js"
 import type { Exit } from "../Exit.js"
 import { dual, identity } from "../Function.js"
 import * as Iterable from "../Iterable.js"
@@ -122,7 +123,7 @@ interface Strategy<A, E> {
   readonly reclaim: (pool: PoolImpl<A, E>) => Effect<Option.Option<PoolItem<A, E>>>
 }
 
-class PoolImpl<A, E> implements Pool<A, E> {
+class PoolImpl<A, E> extends Effectable.Class<A, E, Scope> implements Pool<A, E> {
   readonly [PoolTypeId]: Pool.Variance<A, E>[PoolTypeId_]
 
   isShuttingDown = false
@@ -140,6 +141,7 @@ class PoolImpl<A, E> implements Pool<A, E> {
     readonly strategy: Strategy<A, E>,
     readonly targetUtilization: number
   ) {
+    super()
     this[PoolTypeId] = poolVariance
     this.semaphore = circular.unsafeMakeSemaphore(concurrency * maxSize)
   }
@@ -253,6 +255,10 @@ class PoolImpl<A, E> implements Pool<A, E> {
     )
   )
 
+  commit() {
+    return this.get
+  }
+
   readonly get: Effect<A, E, Scope> = core.flatMap(
     core.suspend(() => this.isShuttingDown ? core.interrupt : this.getPoolItem),
     (_) => _.exit

package/src/internal/redBlackTree.ts

@@ -2,7 +2,7 @@ import * as Chunk from "../Chunk.js"
 import * as Equal from "../Equal.js"
 import { dual, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
 import type * as Ordering from "../Ordering.js"
@@ -71,6 +71,9 @@ const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
       values: Array.from(this).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/internal/resource.ts

@@ -4,6 +4,7 @@ import type * as Resource from "../Resource.js"
 import type * as Schedule from "../Schedule.js"
 import type * as Scope from "../Scope.js"
 import * as core from "./core.js"
+import * as effectable from "./effectable.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as _schedule from "./schedule.js"
 import * as scopedRef from "./scopedRef.js"
@@ -23,6 +24,15 @@ const resourceVariance = {
   _A: (_: any) => _
 }
 
+/** @internal  */
+const proto: ThisType<Resource.Resource<any, any>> = {
+  ...effectable.CommitPrototype,
+  commit() {
+    return get(this)
+  },
+  [ResourceTypeId]: resourceVariance
+}
+
 /** @internal */
 export const auto = <A, E, R, Out, R2>(
   acquire: Effect.Effect<A, E, R>,
@@ -46,11 +56,12 @@ export const manual = <A, E, R>(
   core.flatMap(core.context<R>(), (env) =>
     pipe(
       scopedRef.fromAcquire(core.exit(acquire)),
-      core.map((ref) => ({
-        [ResourceTypeId]: resourceVariance,
-        scopedRef: ref,
-        acquire: core.provideContext(acquire, env)
-      }))
+      core.map((ref) => {
+        const resource = Object.create(proto)
+        resource.scopedRef = ref
+        resource.acquire = core.provideContext(acquire, env)
+        return resource
+      })
     ))
 
 /** @internal */

package/src/internal/runtime.ts

@@ -195,6 +195,9 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
   toString(): string {
     return "(FiberFailure) " + (this.stack ?? this.message)
   }
+  [Inspectable.DenoInspectSymbol](): unknown {
+    return this.toString()
+  }
   [Inspectable.NodeInspectSymbol](): unknown {
     return this.toString()
   }

package/src/internal/scopedRef.ts

@@ -2,11 +2,11 @@ import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
 import type { LazyArg } from "../Function.js"
 import { dual, pipe } from "../Function.js"
-import { pipeArguments } from "../Pipeable.js"
 import type * as Scope from "../Scope.js"
 import type * as ScopedRef from "../ScopedRef.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
+import * as effectable from "./effectable.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as ref from "./ref.js"
 import * as synchronized from "./synchronizedRef.js"
@@ -25,6 +25,15 @@ const scopedRefVariance = {
   _A: (_: any) => _
 }
 
+/** @internal  */
+const proto: ThisType<ScopedRef.ScopedRef<any>> = {
+  ...effectable.CommitPrototype,
+  commit() {
+    return get(this)
+  },
+  [ScopedRefTypeId]: scopedRefVariance
+}
+
 /** @internal  */
 const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<void> =>
   core.flatMap(ref.get(self.ref), (tuple) => tuple[0].close(core.exitVoid))
@@ -41,13 +50,8 @@ export const fromAcquire = <A, E, R>(
         core.flatMap((value) =>
           circular.makeSynchronized([newScope, value] as const).pipe(
             core.flatMap((ref) => {
-              const scopedRef: ScopedRef.ScopedRef<A> = {
-                [ScopedRefTypeId]: scopedRefVariance,
-                pipe() {
-                  return pipeArguments(this, arguments)
-                },
-                ref
-              }
+              const scopedRef = Object.create(proto)
+              scopedRef.ref = ref
               return pipe(
                 fiberRuntime.addFinalizer(() => close(scopedRef)),
                 core.as(scopedRef)

package/src/internal/stm/core.ts

@@ -56,7 +56,7 @@ export type Primitive =
 
 /** @internal */
 type Op<Tag extends string, Body = {}> = STM.STM<never> & Body & {
-  readonly _tag: OP_COMMIT
+  readonly _op: OP_COMMIT
   readonly effect_instruction_i0: Tag
 }
 
@@ -150,7 +150,6 @@ const stmVariance = {
 
 /** @internal */
 class STMPrimitive implements STM.STM<any, any, any> {
-  public _tag = OP_COMMIT
   public _op = OP_COMMIT
   public effect_instruction_i1: any = undefined
   public effect_instruction_i2: any = undefined;
@@ -481,7 +480,7 @@ export class STMDriver<in out R, out E, out A> {
       try {
         const current = curr
         if (current) {
-          switch (current._tag) {
+          switch (current._op) {
             case "Tag": {
               curr = effect((_, __, env) => Context.unsafeGet(env, current)) as Primitive
               break

package/src/internal/trie.ts

@@ -1,7 +1,7 @@
 import * as Equal from "../Equal.js"
 import { dual, identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import type * as Ordering from "../Ordering.js"
 import { pipeArguments } from "../Pipeable.js"
@@ -60,6 +60,9 @@ const TrieProto: TR.Trie<unknown> = {
       values: Array.from(this).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.8.5"
+let moduleVersion = "3.9.0"
 
 export const getCurrentVersion = () => moduleVersion