effect 3.8.5 → 3.9.1

package/src/internal/layer.ts

@@ -10,6 +10,7 @@ import type { LazyArg } from "../Function.js"
 import { dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
 import type * as Layer from "../Layer.js"
+import type * as ManagedRuntime from "../ManagedRuntime.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
@@ -23,6 +24,7 @@ import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
 import * as fiberRuntime from "./fiberRuntime.js"
+import * as circularManagedRuntime from "./managedRuntime/circular.js"
 import * as EffectOpCodes from "./opCodes/effect.js"
 import * as OpCodes from "./opCodes/layer.js"
 import * as ref from "./ref.js"
@@ -49,7 +51,7 @@ const layerVariance = {
 }
 
 /** @internal */
-const proto = {
+export const proto = {
   [LayerTypeId]: layerVariance,
   pipe() {
     return pipeArguments(this, arguments)
@@ -79,7 +81,7 @@ export type Primitive =
 
 /** @internal */
 export type Op<Tag extends string, Body = {}> = Layer.Layer<unknown, unknown, unknown> & Body & {
-  readonly _tag: Tag
+  readonly _op_layer: Tag
 }
 
 /** @internal */
@@ -165,7 +167,7 @@ export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown>
 
 /** @internal */
 export const isFresh = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): boolean => {
-  return (self as Primitive)._tag === OpCodes.OP_FRESH
+  return (self as Primitive)._op_layer === OpCodes.OP_FRESH
 }
 
 // -----------------------------------------------------------------------------
@@ -356,7 +358,7 @@ const makeBuilder = <RIn, E, ROut>(
   inMemoMap = false
 ): Effect.Effect<(memoMap: Layer.MemoMap) => Effect.Effect<Context.Context<ROut>, E, RIn>> => {
   const op = self as Primitive
-  switch (op._tag) {
+  switch (op._op_layer) {
     case "Locally": {
       return core.sync(() => (memoMap: Layer.MemoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope)))
     }
@@ -487,7 +489,7 @@ export const extendScope = <RIn, E, ROut>(
   self: Layer.Layer<ROut, E, RIn>
 ): Layer.Layer<ROut, E, RIn | Scope.Scope> => {
   const extendScope = Object.create(proto)
-  extendScope._tag = OpCodes.OP_EXTEND_SCOPE
+  extendScope._op_layer = OpCodes.OP_EXTEND_SCOPE
   extendScope.layer = self
   return extendScope
 }
@@ -533,7 +535,7 @@ export const flatten = dual<
 /** @internal */
 export const fresh = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, E, R> => {
   const fresh = Object.create(proto)
-  fresh._tag = OpCodes.OP_FRESH
+  fresh._op_layer = OpCodes.OP_FRESH
   fresh.layer = self
   return fresh
 }
@@ -565,7 +567,7 @@ export function fromEffectContext<A, E, R>(
   effect: Effect.Effect<Context.Context<A>, E, R>
 ): Layer.Layer<A, E, R> {
   const fromEffect = Object.create(proto)
-  fromEffect._tag = OpCodes.OP_FROM_EFFECT
+  fromEffect._op_layer = OpCodes.OP_FROM_EFFECT
   fromEffect.effect = effect
   return fromEffect
 }
@@ -587,7 +589,7 @@ export const locallyEffect = dual<
   ) => Layer.Layer<ROut2, E2, RIn2>
 >(2, (self, f) => {
   const locally = Object.create(proto)
-  locally._tag = "Locally"
+  locally._op_layer = "Locally"
   locally.self = self
   locally.f = f
   return locally
@@ -658,7 +660,7 @@ export const matchCause = dual<
   ) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>
 >(2, (self, { onFailure, onSuccess }) => {
   const fold = Object.create(proto)
-  fold._tag = OpCodes.OP_FOLD
+  fold._op_layer = OpCodes.OP_FOLD
   fold.layer = self
   fold.failureK = onFailure
   fold.successK = onSuccess
@@ -866,7 +868,7 @@ export const scopedContext = <A, E, R>(
   effect: Effect.Effect<Context.Context<A>, E, R>
 ): Layer.Layer<A, E, Exclude<R, Scope.Scope>> => {
   const scoped = Object.create(proto)
-  scoped._tag = OpCodes.OP_SCOPED
+  scoped._op_layer = OpCodes.OP_SCOPED
   scoped.effect = effect
   return scoped
 }
@@ -920,7 +922,7 @@ export const suspend = <RIn, E, ROut>(
   evaluate: LazyArg<Layer.Layer<ROut, E, RIn>>
 ): Layer.Layer<ROut, E, RIn> => {
   const suspend = Object.create(proto)
-  suspend._tag = OpCodes.OP_SUSPEND
+  suspend._op_layer = OpCodes.OP_SUSPEND
   suspend.evaluate = evaluate
   return suspend
 }
@@ -1024,29 +1026,52 @@ export const toRuntimeWithMemoMap = dual<
 
 /** @internal */
 export const provide = dual<
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>
-  ) => <RIn2, E2, ROut2>(
-    that: Layer.Layer<ROut2, E2, RIn2>
-  ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>,
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer.Layer<ROut2, E2, RIn2>,
-    self: Layer.Layer<ROut, E, RIn>
-  ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
->(2, <RIn2, E2, ROut2, RIn, E, ROut>(
-  that: Layer.Layer<ROut2, E2, RIn2>,
-  self: Layer.Layer<ROut, E, RIn>
+  {
+    <RIn, E, ROut>(
+      that: Layer.Layer<ROut, E, RIn>
+    ): <RIn2, E2, ROut2>(
+      self: Layer.Layer<ROut2, E2, RIn2>
+    ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+    <const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      that: Layers
+    ): <A, E, R>(
+      self: Layer.Layer<A, E, R>
+    ) => Layer.Layer<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
+  },
+  {
+    <RIn2, E2, ROut2, RIn, E, ROut>(
+      self: Layer.Layer<ROut2, E2, RIn2>,
+      that: Layer.Layer<ROut, E, RIn>
+    ): Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+    <A, E, R, const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      self: Layer.Layer<A, E, R>,
+      that: Layers
+    ): Layer.Layer<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
+  }
+>(2, (
+  self: Layer.Layer.Any,
+  that: Layer.Layer.Any | ReadonlyArray<Layer.Layer.Any>
 ) =>
   suspend(() => {
     const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE
+    provideTo._op_layer = OpCodes.OP_PROVIDE
     provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
-      first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
-      second: { value: self },
-      zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => pipe(a, Context.merge(b)) }
+      _op_layer: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
+      first: { value: context(), enumerable: true },
+      second: { value: Array.isArray(that) ? mergeAll(...that as any) : that },
+      zipK: { value: (a: Context.Context<any>, b: Context.Context<any>) => pipe(a, Context.merge(b)) }
     })
-    provideTo.second = that
+    provideTo.second = self
     return provideTo
   }))
 
@@ -1063,7 +1088,7 @@ export const provideMerge = dual<
   ) => Layer.Layer<ROut | ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>
 >(2, <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer.Layer<ROut2, E2, RIn2>, self: Layer.Layer<ROut, E, RIn>) => {
   const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_PROVIDE_MERGE
+  zipWith._op_layer = OpCodes.OP_PROVIDE_MERGE
   zipWith.first = self
   zipWith.second = provide(that, self)
   zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> => {
@@ -1086,7 +1111,7 @@ export const zipWith = dual<
 >(3, (self, that, f) =>
   suspend(() => {
     const zipWith = Object.create(proto)
-    zipWith._tag = OpCodes.OP_ZIP_WITH
+    zipWith._op_layer = OpCodes.OP_ZIP_WITH
     zipWith.first = self
     zipWith.second = that
     zipWith.zipK = f
@@ -1291,6 +1316,16 @@ const provideSomeRuntime = dual<
 /** @internal */
 export const effect_provide = dual<
   {
+    <const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      layers: Layers
+    ): <A, E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
     <ROut, E2, RIn>(
       layer: Layer.Layer<ROut, E2, RIn>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
@@ -1300,8 +1335,20 @@ export const effect_provide = dual<
     <R2>(
       runtime: Runtime.Runtime<R2>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
+    <E2, R2>(
+      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
+    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, Exclude<R, R2>>
   },
   {
+    <A, E, R, const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      self: Effect.Effect<A, E, R>,
+      layers: Layers
+    ): Effect.Effect<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
     <A, E, R, ROut, E2, RIn>(
       self: Effect.Effect<A, E, R>,
       layer: Layer.Layer<ROut, E2, RIn>
@@ -1314,16 +1361,36 @@ export const effect_provide = dual<
       self: Effect.Effect<A, E, R>,
       runtime: Runtime.Runtime<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
+    <A, E, E2, R, R2>(
+      self: Effect.Effect<A, E, R>,
+      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
+    ): Effect.Effect<A, E | E2, Exclude<R, R2>>
   }
 >(
   2,
   <A, E, R, ROut>(
     self: Effect.Effect<A, E, R>,
-    source: Layer.Layer<ROut, any, any> | Context.Context<ROut> | Runtime.Runtime<ROut>
-  ): Effect.Effect<any, any, Exclude<R, ROut>> =>
-    isLayer(source)
-      ? provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
-      : Context.isContext(source)
-      ? core.provideSomeContext(self, source)
-      : provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
+    source:
+      | Layer.Layer<ROut, any, any>
+      | Context.Context<ROut>
+      | Runtime.Runtime<ROut>
+      | ManagedRuntime.ManagedRuntime<ROut, any>
+      | Array<Layer.Layer.Any>
+  ): Effect.Effect<any, any, Exclude<R, ROut>> => {
+    if (Array.isArray(source)) {
+      // @ts-expect-error
+      return provideSomeLayer(self, mergeAll(...source))
+    } else if (isLayer(source)) {
+      return provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
+    } else if (Context.isContext(source)) {
+      return core.provideSomeContext(self, source)
+    } else if (circularManagedRuntime.TypeId in source) {
+      return core.flatMap(
+        (source as ManagedRuntime.ManagedRuntime<ROut, any>).runtimeEffect,
+        (rt) => provideSomeRuntime(self, rt)
+      )
+    } else {
+      return provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
+    }
+  }
 )

package/src/internal/managedRuntime/circular.ts

@@ -0,0 +1,6 @@
+import type * as M from "../../ManagedRuntime.js"
+
+// circular with Layer
+
+/** @internal */
+export const TypeId: M.TypeId = Symbol.for("effect/ManagedRuntime") as M.TypeId

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/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/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/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/version.ts

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