build the accessor inside acquisuon

Author: tim-smart

packages/effect/src/LayerMap.ts

@@ -31,7 +31,7 @@ export interface LayerMap<in K, in out I, out S, out E = never> {
   /**
    * The internal RcMap that stores the resources.
    */
-  readonly rcMap: RcMap.RcMap<K, Context.Context<I>, E>
+  readonly rcMap: RcMap.RcMap<K, readonly [Context.Context<I>, S], E>
 
   /**
    * Retrieves an instance of the resource associated with the key.
@@ -100,18 +100,23 @@ export interface LayerMap<in K, in out I, out S, out E = never> {
  * )
  * ```
  */
-export const make: <I, S, K, L extends Layer.Layer<I, any, any>>(
-  tag: Context.Tag<I, S> | Effect.Effect<S, never, I>,
+export const make: <I, S, K, L extends Layer.Layer<Exclude<I, Scope.Scope>, any, any>, E = never>(
+  tagOrAccessor: Context.Tag<I, S> | Effect.Effect<S, E, I>,
   lookup: (key: K) => L,
   options?: {
     readonly idleTimeToLive?: DurationInput | undefined
   } | undefined
 ) => Effect.Effect<
-  LayerMap<K, I, S, L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never>,
+  LayerMap<
+    K,
+    Exclude<I, Scope.Scope>,
+    S,
+    E | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never)
+  >,
   never,
   Scope.Scope | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> = Effect.fnUntraced(function*<I, S, K, L extends Layer.Layer<I, any, any>>(
-  tag: Context.Tag<I, S> | Effect.Effect<S, never, I>,
+> = Effect.fnUntraced(function*<I, S, K, L extends Layer.Layer<Exclude<I, Scope.Scope>, any, any>, E = never>(
+  tagOrAccessor: Context.Tag<I, S> | Effect.Effect<S, E, I>,
   lookup: (key: K) => L,
   options?: {
     readonly idleTimeToLive?: DurationInput | undefined
@@ -126,27 +131,25 @@ export const make: <I, S, K, L extends Layer.Layer<I, any, any>>(
     : yield* Layer.makeMemoMap
 
   const rcMap = yield* RcMap.make({
-    lookup: (key: K) =>
-      Effect.scopeWith((scope) =>
-        Layer.buildWithMemoMap(lookup(key), memoMap, scope) as Effect.Effect<
-          Context.Context<I>
-        >
-      ),
+    lookup: Effect.fnUntraced(function*(key: K) {
+      const scope = yield* Effect.scope
+      const context = yield* (Layer.buildWithMemoMap(lookup(key), memoMap, scope) as Effect.Effect<
+        Context.Context<Exclude<I, Scope.Scope>>
+      >)
+      const service = yield* (Effect.provide(tagOrAccessor, context) as Effect.Effect<S>)
+      return [context, service] as const
+    }),
     idleTimeToLive: options?.idleTimeToLive
   })
 
-  return identity<LayerMap<K, I, S, any>>({
+  return identity<LayerMap<K, Exclude<I, Scope.Scope>, S, any>>({
     [TypeId]: TypeId,
     rcMap,
-    get: (key) =>
-      Effect.flatMap(
-        RcMap.get(rcMap, key),
-        (context) => Effect.provide(tag, context)
-      ),
+    get: (key) => Effect.map(RcMap.get(rcMap, key), ([, service]) => service),
     provide: (key) => (effect) =>
       Effect.flatMap(
         RcMap.get(rcMap, key),
-        (context) => Effect.provide(effect, context)
+        ([context]) => Effect.provide(effect, context)
       ),
     invalidate: (key) => RcMap.invalidate(rcMap, key)
   })
@@ -156,14 +159,24 @@ export const make: <I, S, K, L extends Layer.Layer<I, any, any>>(
  * @since 3.13.0
  * @category Constructors
  */
-export const fromRecord = <I, S, const Layers extends Record<string, Layer.Layer<I, any, any>>>(
-  tag: Context.Tag<I, S> | Effect.Effect<S, never, I>,
+export const fromRecord = <
+  I,
+  S,
+  const Layers extends Record<string, Layer.Layer<Exclude<I, Scope.Scope>, any, any>>,
+  E = never
+>(
+  tagOrAccessor: Context.Tag<I, S> | Effect.Effect<S, E, I>,
   layers: Layers,
   options?: {
     readonly idleTimeToLive?: DurationInput | undefined
   } | undefined
 ): Effect.Effect<
-  LayerMap<keyof Layers, I, S, Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never>,
+  LayerMap<
+    keyof Layers,
+    Exclude<I, Scope.Scope>,
+    S,
+    E | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never)
+  >,
   never,
   Scope.Scope | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> => make(tag, (key: keyof Layers) => layers[key], options)
+> => make(tagOrAccessor, (key: keyof Layers) => layers[key], options)