effect 2.4.2 → 2.4.4

package/src/ManagedRuntime.ts

@@ -0,0 +1,119 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import type * as Fiber from "./Fiber.js"
+import * as internal from "./internal/managedRuntime.js"
+import type * as Layer from "./Layer.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Runtime from "./Runtime.js"
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface ManagedRuntime<in R, out ER> extends Pipeable {
+  readonly memoMap: Layer.MemoMap
+  readonly runtimeEffect: Effect.Effect<Runtime.Runtime<R>, ER>
+  readonly runtime: () => Promise<Runtime.Runtime<R>>
+
+  /**
+   * Executes the effect using the provided Scheduler or using the global
+   * Scheduler if not provided
+   */
+  readonly runFork: <A, E>(
+    self: Effect.Effect<A, E, R>,
+    options?: Runtime.RunForkOptions
+  ) => Fiber.RuntimeFiber<A, E | ER>
+
+  /**
+   * Executes the effect synchronously returning the exit.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   */
+  readonly runSyncExit: <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, ER | E>
+
+  /**
+   * Executes the effect synchronously throwing in case of errors or async boundaries.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   */
+  readonly runSync: <A, E>(effect: Effect.Effect<A, E, R>) => A
+
+  /**
+   * Executes the effect asynchronously, eventually passing the exit value to
+   * the specified callback.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   */
+  readonly runCallback: <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: Runtime.RunCallbackOptions<A, E | ER> | undefined
+  ) => Runtime.Cancel<A, E | ER>
+
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the value of the effect once the effect has been executed, or will be
+   * rejected with the first error or exception throw by the effect.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   */
+  readonly runPromise: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+    readonly signal?: AbortSignal | undefined
+  }) => Promise<A>
+
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the `Exit` state of the effect once the effect has been executed.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   */
+  readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+    readonly signal?: AbortSignal | undefined
+  }) => Promise<Exit.Exit<A, ER | E>>
+
+  /**
+   * Dispose of the resources associated with the runtime.
+   */
+  readonly dispose: () => Promise<void>
+
+  /**
+   * Dispose of the resources associated with the runtime.
+   */
+  readonly disposeEffect: Effect.Effect<void, never, never>
+}
+
+/**
+ * Convert a Layer into an ManagedRuntime, that can be used to run Effect's using
+ * your services.
+ *
+ * @since 2.0.0
+ * @category runtime class
+ * @example
+ * import { Console, Effect, Layer, ManagedRuntime } from "effect"
+ *
+ * class Notifications extends Effect.Tag("Notifications")<
+ *   Notifications,
+ *   { readonly notify: (message: string) => Effect.Effect<void> }
+ * >() {
+ *   static Live = Layer.succeed(this, { notify: (message) => Console.log(message) })
+ * }
+ *
+ * async function main() {
+ *   const runtime = ManagedRuntime.make(Notifications.Live)
+ *   await runtime.runPromise(Notifications.notify("Hello, world!"))
+ *   await runtime.dispose()
+ * }
+ *
+ * main()
+ */
+export const make: <R, E>(
+  layer: Layer.Layer<R, E, never>,
+  memoMap?: Layer.MemoMap | undefined
+) => ManagedRuntime<R, E> = internal.make

package/src/Predicate.ts

@@ -543,6 +543,14 @@ export const isPromise = (
 ): input is Promise<unknown> =>
   hasProperty(input, "then") && "catch" in input && isFunction(input.then) && isFunction(input.catch)
 
+/**
+ * @category guards
+ * @since 2.0.0
+ */
+export const isPromiseLike = (
+  input: unknown
+): input is PromiseLike<unknown> => hasProperty(input, "then") && isFunction(input.then)
+
 /**
  * @since 2.0.0
  */

package/src/Runtime.ts

@@ -134,7 +134,9 @@ export const runCallback: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A> =
+export const runPromise: <R>(
+  runtime: Runtime<R>
+) => <A, E>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal } | undefined) => Promise<A> =
   internal.unsafeRunPromise
 
 /**
@@ -149,7 +151,10 @@ export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effec
  */
 export const runPromiseExit: <R>(
   runtime: Runtime<R>
-) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
+) => <A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: { readonly signal?: AbortSignal } | undefined
+) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
 
 /**
  * @since 2.0.0

package/src/index.ts

@@ -385,6 +385,11 @@ export * as LogSpan from "./LogSpan.js"
  */
 export * as Logger from "./Logger.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as ManagedRuntime from "./ManagedRuntime.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/blockedRequests.ts

@@ -1,3 +1,4 @@
+import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
@@ -251,9 +252,9 @@ const step = (
         break
       }
       case "Single": {
-        parallel = parallelCollectionCombine(
+        parallel = parallelCollectionAdd(
           parallel,
-          parallelCollectionMake(current.dataSource, current.blockedRequest)
+          current
         )
         if (List.isNil(stack)) {
           return [parallel, sequential]
@@ -360,7 +361,7 @@ class ParallelImpl implements ParallelCollection {
   constructor(
     readonly map: HashMap.HashMap<
       RequestResolver.RequestResolver<unknown, unknown>,
-      Array<Request.Entry<unknown>>
+      Chunk.Chunk<Request.Entry<unknown>>
     >
   ) {}
 }
@@ -372,7 +373,22 @@ export const parallelCollectionEmpty = (): ParallelCollection => new ParallelImp
 export const parallelCollectionMake = <A>(
   dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-): ParallelCollection => new ParallelImpl(HashMap.make([dataSource, Array.of(blockedRequest)]) as any)
+): ParallelCollection => new ParallelImpl(HashMap.make([dataSource, Chunk.of(blockedRequest)]) as any)
+
+/** @internal */
+export const parallelCollectionAdd = (
+  self: ParallelCollection,
+  blockedRequest: RequestBlock.Single
+): ParallelCollection =>
+  new ParallelImpl(HashMap.modifyAt(
+    self.map,
+    blockedRequest.dataSource,
+    (_) =>
+      Option.orElseSome(
+        Option.map(_, Chunk.append(blockedRequest.blockedRequest)),
+        () => Chunk.of(blockedRequest.blockedRequest)
+      )
+  ))
 
 /** @internal */
 export const parallelCollectionCombine = (
@@ -385,7 +401,7 @@ export const parallelCollectionCombine = (
       key,
       Option.match(HashMap.get(map, key), {
         onNone: () => value,
-        onSome: (other) => [...value, ...other]
+        onSome: (other) => Chunk.appendAll(value, other)
       })
     )))
 
@@ -400,7 +416,7 @@ export const parallelCollectionKeys = (
 /** @internal */
 export const parallelCollectionToSequentialCollection = (
   self: ParallelCollection
-): SequentialCollection => sequentialCollectionMake(HashMap.map(self.map, (x) => Array.of(x)) as any)
+): SequentialCollection => sequentialCollectionMake(HashMap.map(self.map, (x) => Chunk.of(x)) as any)
 
 // TODO
 // /** @internal */
@@ -423,7 +439,7 @@ class SequentialImpl implements SequentialCollection {
   constructor(
     readonly map: HashMap.HashMap<
       RequestResolver.RequestResolver<unknown, unknown>,
-      Array<Array<Request.Entry<unknown>>>
+      Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>
     >
   ) {}
 }
@@ -432,7 +448,7 @@ class SequentialImpl implements SequentialCollection {
 export const sequentialCollectionMake = <A, R>(
   map: HashMap.HashMap<
     RequestResolver.RequestResolver<A, R>,
-    Array<Array<Request.Entry<A>>>
+    Chunk.Chunk<Chunk.Chunk<Request.Entry<A>>>
   >
 ): SequentialCollection => new SequentialImpl(map as any)
 
@@ -446,8 +462,8 @@ export const sequentialCollectionCombine = (
       map,
       key,
       Option.match(HashMap.get(map, key), {
-        onNone: () => [],
-        onSome: (a) => [...a, ...value]
+        onNone: () => Chunk.empty(),
+        onSome: (a) => Chunk.appendAll(a, value)
       })
     )))
 
@@ -462,7 +478,7 @@ export const sequentialCollectionKeys = (
 /** @internal */
 export const sequentialCollectionToChunk = (
   self: SequentialCollection
-): Array<[RequestResolver.RequestResolver<unknown>, Array<Array<Request.Entry<unknown>>>]> =>
+): Array<[RequestResolver.RequestResolver<unknown>, Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>]> =>
   Array.from(self.map) as any
 
 /** @internal */
@@ -472,7 +488,7 @@ export type RequestBlockParallelTypeId = typeof RequestBlockParallelTypeId
 export interface ParallelCollection extends ParallelCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
-    Array<Request.Entry<unknown>>
+    Chunk.Chunk<Request.Entry<unknown>>
   >
 }
 
@@ -491,7 +507,7 @@ export type SequentialCollectionTypeId = typeof SequentialCollectionTypeId
 export interface SequentialCollection extends SequentialCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
-    Array<Array<Request.Entry<unknown>>>
+    Chunk.Chunk<Chunk.Chunk<Request.Entry<unknown>>>
   >
 }
 

package/src/internal/core-effect.ts

@@ -1171,17 +1171,15 @@ export const patchFiberRefs = (patch: FiberRefsPatch.FiberRefsPatch): Effect.Eff
   updateFiberRefs((fiberId, fiberRefs) => pipe(patch, fiberRefsPatch.patch(fiberId, fiberRefs)))
 
 /* @internal */
-export const promise = <A>(evaluate: (signal: AbortSignal) => Promise<A>): Effect.Effect<A> =>
+export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A> =>
   evaluate.length >= 1
     ? core.async((resolve, signal) => {
       evaluate(signal)
-        .then((a) => resolve(core.exitSucceed(a)))
-        .catch((e) => resolve(core.exitDie(e)))
+        .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
     })
     : core.async((resolve) => {
-      ;(evaluate as LazyArg<Promise<A>>)()
-        .then((a) => resolve(core.exitSucceed(a)))
-        .catch((e) => resolve(core.exitDie(e)))
+      ;(evaluate as LazyArg<PromiseLike<A>>)()
+        .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
     })
 
 /* @internal */
@@ -1620,23 +1618,23 @@ export const tracer: Effect.Effect<Tracer.Tracer> = tracerWith(core.succeed)
 export const tryPromise: {
   <A, E>(
     options: {
-      readonly try: (signal: AbortSignal) => Promise<A>
+      readonly try: (signal: AbortSignal) => PromiseLike<A>
       readonly catch: (error: unknown) => E
     }
   ): Effect.Effect<A, E>
-  <A>(try_: (signal: AbortSignal) => Promise<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(try_: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
-  arg: ((signal: AbortSignal) => Promise<A>) | {
-    readonly try: (signal: AbortSignal) => Promise<A>
+  arg: ((signal: AbortSignal) => PromiseLike<A>) | {
+    readonly try: (signal: AbortSignal) => PromiseLike<A>
     readonly catch: (error: unknown) => E
   }
 ): Effect.Effect<A, E | Cause.UnknownException> => {
-  let evaluate: (signal?: AbortSignal) => Promise<A>
+  let evaluate: (signal?: AbortSignal) => PromiseLike<A>
   let catcher: ((error: unknown) => E) | undefined = undefined
   if (typeof arg === "function") {
-    evaluate = arg as (signal?: AbortSignal) => Promise<A>
+    evaluate = arg as (signal?: AbortSignal) => PromiseLike<A>
   } else {
-    evaluate = arg.try as (signal?: AbortSignal) => Promise<A>
+    evaluate = arg.try as (signal?: AbortSignal) => PromiseLike<A>
     catcher = arg.catch
   }
 
@@ -1644,12 +1642,10 @@ export const tryPromise: {
     return core.async((resolve, signal) => {
       try {
         evaluate(signal)
-          .then((a) => resolve(core.exitSucceed(a)))
-          .catch((e) =>
+          .then((a) => resolve(core.exitSucceed(a)), (e) =>
             resolve(core.fail(
               catcher ? catcher(e) : new core.UnknownException(e)
-            ))
-          )
+            )))
       } catch (e) {
         resolve(core.fail(
           catcher ? catcher(e) : new core.UnknownException(e)
@@ -1661,12 +1657,10 @@ export const tryPromise: {
   return core.async((resolve) => {
     try {
       evaluate()
-        .then((a) => resolve(core.exitSucceed(a)))
-        .catch((e) =>
+        .then((a) => resolve(core.exitSucceed(a)), (e) =>
           resolve(core.fail(
             catcher ? catcher(e) : new core.UnknownException(e)
-          ))
-        )
+          )))
     } catch (e) {
       resolve(core.fail(
         catcher ? catcher(e) : new core.UnknownException(e)
@@ -1701,21 +1695,21 @@ export const tryMap = dual<
 export const tryMapPromise = dual<
   <A, B, E1>(
     options: {
-      readonly try: (a: A, signal: AbortSignal) => Promise<B>
+      readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
       readonly catch: (error: unknown) => E1
     }
   ) => <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E | E1, R>,
   <A, E, R, B, E1>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly try: (a: A, signal: AbortSignal) => Promise<B>
+      readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
       readonly catch: (error: unknown) => E1
     }
   ) => Effect.Effect<B, E | E1, R>
 >(2, <A, E, R, B, E1>(
   self: Effect.Effect<A, E, R>,
   options: {
-    readonly try: (a: A, signal: AbortSignal) => Promise<B>
+    readonly try: (a: A, signal: AbortSignal) => PromiseLike<B>
     readonly catch: (error: unknown) => E1
   }
 ) =>
@@ -1723,7 +1717,7 @@ export const tryMapPromise = dual<
     tryPromise({
       try: options.try.length >= 1
         ? (signal) => options.try(a, signal)
-        : () => (options.try as (a: A) => Promise<B>)(a),
+        : () => (options.try as (a: A) => PromiseLike<B>)(a),
       catch: options.catch
     })))
 

package/src/internal/core.ts

@@ -26,7 +26,7 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isObject, isPromise, isString, type Predicate, type Refinement } from "../Predicate.js"
+import { hasProperty, isObject, isPromiseLike, isString, type Predicate, type Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
@@ -694,35 +694,35 @@ export const andThen: {
   ): <E, R>(
     self: Effect.Effect<A, E, R>
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <X>(
     f: NotFunction<X>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: (a: NoInfer<A>) => X
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: NotFunction<X>
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
 } = dual(2, (self, f) =>
   flatMap(self, (a) => {
     const b = typeof f === "function" ? (f as any)(a) : f
     if (isEffect(b)) {
       return b
-    } else if (isPromise(b)) {
+    } else if (isPromiseLike(b)) {
       return async<any, Cause.UnknownException>((resume) => {
-        b.then((a) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+        b.then((a) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
       })
     }
     return succeed(b)
@@ -1166,14 +1166,14 @@ export const tap = dual<
     ): <E, R>(
       self: Effect.Effect<A, E, R>
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
     <X>(
       f: NotFunction<X>
     ): <A, E, R>(
       self: Effect.Effect<A, E, R>
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
   },
   {
@@ -1181,13 +1181,13 @@ export const tap = dual<
       self: Effect.Effect<A, E, R>,
       f: (a: NoInfer<A>) => X
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
     <A, E, R, X>(
       self: Effect.Effect<A, E, R>,
       f: NotFunction<X>
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
   }
 >(2, (self, f) =>
@@ -1195,9 +1195,9 @@ export const tap = dual<
     const b = typeof f === "function" ? (f as any)(a) : f
     if (isEffect(b)) {
       return as(b, a)
-    } else if (isPromise(b)) {
+    } else if (isPromiseLike(b)) {
       return async<any, Cause.UnknownException>((resume) => {
-        b.then((_) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+        b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
       })
     }
     return succeed(a)

package/src/internal/fiberRuntime.ts

@@ -234,13 +234,15 @@ const runBlockedRequests = (self: RequestBlock.RequestBlock) =>
         _RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver),
         ([dataSource, sequential]) => {
           const map = new Map<Request<any, any>, Entry<any>>()
+          const arr: Array<Array<Entry<any>>> = []
           for (const block of sequential) {
+            arr.push(Chunk.toReadonlyArray(block) as any)
             for (const entry of block) {
               map.set(entry.request as Request<any, any>, entry)
             }
           }
           return core.fiberRefLocally(
-            invokeWithInterrupt(dataSource.runAll(sequential), sequential.flat()),
+            invokeWithInterrupt(dataSource.runAll(arr), arr.flat()),
             currentRequestMap,
             map
           )

package/src/internal/layer.ts

@@ -312,6 +312,9 @@ export const makeMemoMap: Effect.Effect<Layer.MemoMap> = core.suspend(() =>
   )
 )
 
+/** @internal */
+export const unsafeMakeMemoMap = (): Layer.MemoMap => new MemoMapImpl(circular.unsafeMakeSynchronized(new Map()))
+
 /** @internal */
 export const build = <RIn, E, ROut>(
   self: Layer.Layer<ROut, E, RIn>
@@ -988,9 +991,9 @@ export const tapErrorCause = dual<
 /** @internal */
 export const toRuntime = <RIn, E, ROut>(
   self: Layer.Layer<ROut, E, RIn>
-): Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope> => {
-  return pipe(
-    fiberRuntime.scopeWith((scope) => pipe(self, buildWithScope(scope))),
+): Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope> =>
+  pipe(
+    fiberRuntime.scopeWith((scope) => buildWithScope(self, scope)),
     core.flatMap((context) =>
       pipe(
         runtime.runtime<ROut>(),
@@ -998,7 +1001,25 @@ export const toRuntime = <RIn, E, ROut>(
       )
     )
   )
-}
+
+/** @internal */
+export const toRuntimeWithMemoMap = dual<
+  (
+    memoMap: Layer.MemoMap
+  ) => <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope>,
+  <RIn, E, ROut>(
+    self: Layer.Layer<ROut, E, RIn>,
+    memoMap: Layer.MemoMap
+  ) => Effect.Effect<Runtime.Runtime<ROut>, E, RIn | Scope.Scope>
+>(2, (self, memoMap) =>
+  core.flatMap(
+    fiberRuntime.scopeWith((scope) => buildWithMemoMap(self, memoMap, scope)),
+    (context) =>
+      pipe(
+        runtime.runtime<any>(),
+        core.provideContext(context)
+      )
+  ))
 
 /** @internal */
 export const provide = dual<