effect 3.17.10 → 3.17.12

package/src/LayerMap.ts

@@ -12,7 +12,7 @@ import * as Layer from "./Layer.js"
 import * as RcMap from "./RcMap.js"
 import * as Runtime from "./Runtime.js"
 import * as Scope from "./Scope.js"
-import type { Mutable } from "./Types.js"
+import type { Mutable, NoExcessProperties } from "./Types.js"
 
 /**
  * @since 3.14.0
@@ -113,11 +113,13 @@ export interface LayerMap<in K, in out I, out E = never> {
  */
 export const make: <
   K,
-  L extends Layer.Layer<any, any, any>
+  L extends Layer.Layer<any, any, any>,
+  PreloadKeys extends Iterable<K> | undefined = undefined
 >(
   lookup: (key: K) => L,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly preloadKeys?: PreloadKeys
   } | undefined
 ) => Effect.Effect<
   LayerMap<
@@ -125,12 +127,13 @@ export const make: <
     L extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
     L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
   >,
-  never,
+  PreloadKeys extends undefined ? never : L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
   Scope.Scope | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
 > = Effect.fnUntraced(function*<I, K, EL, RL>(
   lookup: (key: K) => Layer.Layer<I, EL, RL>,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly preloadKeys?: Iterable<K> | undefined
   } | undefined
 ) {
   const context = yield* Effect.context<never>()
@@ -174,6 +177,12 @@ export const make: <
     idleTimeToLive: options?.idleTimeToLive
   })
 
+  if (options?.preloadKeys) {
+    for (const key of options.preloadKeys) {
+      yield* (RcMap.get(rcMap, key) as Effect.Effect<any, EL, RL | Scope.Scope>)
+    }
+  }
+
   return identity<LayerMap<K, Exclude<I, Scope.Scope>, any>>({
     [TypeId]: TypeId,
     rcMap,
@@ -189,21 +198,27 @@ export const make: <
  * @experimental
  */
 export const fromRecord = <
-  const Layers extends Record<string, Layer.Layer<any, any, any>>
+  const Layers extends Record<string, Layer.Layer<any, any, any>>,
+  const Preload extends boolean = false
 >(
   layers: Layers,
   options?: {
     readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly preload?: Preload | undefined
   } | undefined
 ): Effect.Effect<
   LayerMap<
     keyof Layers,
     Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
-    Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
+    Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
   >,
-  never,
+  Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
   Scope.Scope | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
-> => make((key: keyof Layers) => layers[key], options)
+> =>
+  make((key: keyof Layers) => layers[key], {
+    ...options,
+    preloadKeys: options?.preload ? Object.keys(layers) : undefined
+  }) as any
 
 /**
  * @since 3.14.0
@@ -216,6 +231,7 @@ export interface TagClass<
   in out I,
   in out E,
   in out R,
+  in out LE,
   in out Deps extends Layer.Layer<any, any, any>
 > extends Context.TagClass<Self, Id, LayerMap<K, I, E>> {
   /**
@@ -223,7 +239,7 @@ export interface TagClass<
    */
   readonly Default: Layer.Layer<
     Self,
-    (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never),
+    (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never) | LE,
     | Exclude<R, (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never)>
     | (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
   >
@@ -231,7 +247,7 @@ export interface TagClass<
   /**
    * A default layer for the `LayerMap` service without the dependencies provided.
    */
-  readonly DefaultWithoutDependencies: Layer.Layer<Self, never, R>
+  readonly DefaultWithoutDependencies: Layer.Layer<Self, LE, R>
 
   /**
    * Retrieves a Layer for the resources associated with the key.
@@ -305,28 +321,40 @@ export interface TagClass<
 export const Service = <Self>() =>
 <
   const Id extends string,
-  Lookup extends {
-    readonly lookup: (key: any) => Layer.Layer<any, any, any>
-  } | {
-    readonly layers: Record<string, Layer.Layer<any, any, any>>
-  },
-  const Deps extends ReadonlyArray<Layer.Layer<any, any, any>> = []
+  Options extends
+    | NoExcessProperties<
+      {
+        readonly lookup: (key: any) => Layer.Layer<any, any, any>
+        readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
+        readonly idleTimeToLive?: Duration.DurationInput | undefined
+        readonly preloadKeys?:
+          | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
+          | undefined
+      },
+      Options
+    >
+    | NoExcessProperties<{
+      readonly layers: Record<string, Layer.Layer<any, any, any>>
+      readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
+      readonly idleTimeToLive?: Duration.DurationInput | undefined
+      readonly preload?: boolean
+    }, Options>
 >(
   id: Id,
-  options: Lookup & {
-    readonly dependencies?: Deps | undefined
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
-  }
+  options: Options
 ): TagClass<
   Self,
   Id,
-  Lookup extends { readonly lookup: (key: infer K) => any } ? K
-    : Lookup extends { readonly layers: infer Layers } ? keyof Layers
+  Options extends { readonly lookup: (key: infer K) => any } ? K
+    : Options extends { readonly layers: infer Layers } ? keyof Layers
+    : never,
+  Service.Success<Options>,
+  Options extends { readonly preload: true } ? never : Service.Error<Options>,
+  Service.Context<Options>,
+  Options extends { readonly preload: true } ? Service.Error<Options>
+    : Options extends { readonly preloadKey: Iterable<any> } ? Service.Error<Options>
     : never,
-  Service.Success<Lookup>,
-  Service.Error<Lookup>,
-  Service.Context<Lookup>,
-  Deps[number]
+  Options extends { readonly dependencies: ReadonlyArray<any> } ? Options["dependencies"][number] : never
 > => {
   const Err = globalThis.Error as any
   const limit = Err.stackTraceLimit
@@ -335,7 +363,7 @@ export const Service = <Self>() =>
   Err.stackTraceLimit = limit
 
   function TagClass() {}
-  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any>>
+  const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
   Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.GenericTag<Self, any>(id)))
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {

package/src/Predicate.ts

@@ -1025,7 +1025,8 @@ export const isDate = (input: unknown): input is Date => input instanceof Date
  * @category guards
  * @since 2.0.0
  */
-export const isIterable = (input: unknown): input is Iterable<unknown> => hasProperty(input, Symbol.iterator)
+export const isIterable = (input: unknown): input is Iterable<unknown> =>
+  typeof input === "string" || hasProperty(input, Symbol.iterator)
 
 /**
  * A refinement that checks if a value is a record (i.e., a plain object).

package/src/internal/fiber.ts

@@ -131,11 +131,24 @@ export const interruptAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.Ef
 export const interruptAllAs = dual<
   (fiberId: FiberId.FiberId) => (fibers: Iterable<Fiber.Fiber<any, any>>) => Effect.Effect<void>,
   (fibers: Iterable<Fiber.Fiber<any, any>>, fiberId: FiberId.FiberId) => Effect.Effect<void>
->(2, (fibers, fiberId) =>
-  pipe(
-    core.forEachSequentialDiscard(fibers, interruptAsFork(fiberId)),
-    core.zipRight(pipe(fibers, core.forEachSequentialDiscard(_await)))
-  ))
+>(
+  2,
+  core.fnUntraced(function*(fibers, fiberId) {
+    for (const fiber of fibers) {
+      if (isRuntimeFiber(fiber)) {
+        fiber.unsafeInterruptAsFork(fiberId)
+        continue
+      }
+      yield* fiber.interruptAsFork(fiberId)
+    }
+    for (const fiber of fibers) {
+      if (isRuntimeFiber(fiber) && fiber.unsafePoll()) {
+        continue
+      }
+      yield* fiber.await
+    }
+  })
+)
 
 /** @internal */
 export const interruptAsFork = dual<

package/src/internal/fiberRuntime.ts

@@ -6,7 +6,6 @@ import type * as Clock from "../Clock.js"
 import type { ConfigProvider } from "../ConfigProvider.js"
 import * as Context from "../Context.js"
 import type { DefaultServices } from "../DefaultServices.js"
-import * as Deferred from "../Deferred.js"
 import type * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import * as Effectable from "../Effectable.js"
@@ -2630,112 +2629,54 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
   A,
   E,
   R
->(all: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> => {
-  const list = Chunk.fromIterable(all)
-  if (!Chunk.isNonEmpty(list)) {
-    return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
-  }
-  const self = Chunk.headNonEmpty(list)
-  const effects = Chunk.tailNonEmpty(list)
-  const inheritAll = (res: readonly [A, Fiber.Fiber<A, E>]) =>
-    pipe(
-      internalFiber.inheritAll(res[1]),
-      core.as(res[0])
-    )
-  return pipe(
-    core.deferredMake<readonly [A, Fiber.Fiber<A, E>], E>(),
-    core.flatMap((done) =>
-      pipe(
-        Ref.make(effects.length),
-        core.flatMap((fails) =>
-          core.uninterruptibleMask<A, E, R>((restore) =>
-            pipe(
-              fork(core.interruptible(self)),
-              core.flatMap((head) =>
-                pipe(
-                  effects,
-                  core.forEachSequential((effect) => fork(core.interruptible(effect))),
-                  core.map((fibers) => Chunk.unsafeFromArray(fibers)),
-                  core.map((tail) => pipe(tail, Chunk.prepend(head)) as Chunk.Chunk<Fiber.RuntimeFiber<A, E>>),
-                  core.tap((fibers) =>
-                    pipe(
-                      fibers,
-                      RA.reduce(core.void, (effect, fiber) =>
-                        pipe(
-                          effect,
-                          core.zipRight(
-                            pipe(
-                              internalFiber._await(fiber),
-                              core.flatMap(raceAllArbiter(fibers, fiber, done, fails)),
-                              fork,
-                              core.asVoid
-                            )
-                          )
-                        ))
-                    )
-                  ),
-                  core.flatMap((fibers) =>
-                    pipe(
-                      restore(pipe(Deferred.await(done), core.flatMap(inheritAll))),
-                      core.onInterrupt(() =>
-                        pipe(
-                          fibers,
-                          RA.reduce(
-                            core.void,
-                            (effect, fiber) => pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
-                          )
-                        )
-                      )
-                    )
-                  )
-                )
-              )
-            )
-          )
+>(all: Iterable<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R> =>
+  core.withFiberRuntime((state, status) =>
+    core.async<A, E, R>((resume) => {
+      const fibers = new Set<FiberRuntime<A, E>>()
+      let winner: FiberRuntime<A, E> | undefined
+      let failures: Cause.Cause<E> = internalCause.empty
+      const interruptAll = () => {
+        for (const fiber of fibers) {
+          fiber.unsafeInterruptAsFork(state.id())
+        }
+      }
+      let latch = false
+      let empty = true
+      for (const self of all) {
+        empty = false
+        const fiber = unsafeFork(
+          core.interruptible(self),
+          state,
+          status.runtimeFlags
         )
-      )
-    )
+        fibers.add(fiber)
+        fiber.addObserver((exit) => {
+          fibers.delete(fiber)
+          if (!winner) {
+            if (exit._tag === "Success") {
+              latch = true
+              winner = fiber
+              failures = internalCause.empty
+              interruptAll()
+            } else {
+              failures = internalCause.parallel(exit.cause, failures)
+            }
+          }
+          if (latch && fibers.size === 0) {
+            resume(
+              winner ? core.zipRight(internalFiber.inheritAll(winner), winner.unsafePoll()!) : core.failCause(failures)
+            )
+          }
+        })
+        if (winner) break
+      }
+      if (empty) {
+        return resume(core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`)))
+      }
+      latch = true
+      return internalFiber.interruptAllAs(fibers, state.id())
+    })
   )
-}
-
-const raceAllArbiter = <E, E1, A, A1>(
-  fibers: Iterable<Fiber.Fiber<A | A1, E | E1>>,
-  winner: Fiber.Fiber<A | A1, E | E1>,
-  deferred: Deferred.Deferred<readonly [A | A1, Fiber.Fiber<A | A1, E | E1>], E | E1>,
-  fails: Ref.Ref<number>
-) =>
-(exit: Exit.Exit<A | A1, E | E1>): Effect.Effect<void> =>
-  core.exitMatchEffect(exit, {
-    onFailure: (cause) =>
-      pipe(
-        Ref.modify(fails, (fails) =>
-          [
-            fails === 0 ?
-              pipe(core.deferredFailCause(deferred, cause), core.asVoid) :
-              core.void,
-            fails - 1
-          ] as const),
-        core.flatten
-      ),
-    onSuccess: (value): Effect.Effect<void> =>
-      pipe(
-        core.deferredSucceed(deferred, [value, winner] as const),
-        core.flatMap((set) =>
-          set ?
-            pipe(
-              Chunk.fromIterable(fibers),
-              RA.reduce(
-                core.void,
-                (effect, fiber) =>
-                  fiber === winner ?
-                    effect :
-                    pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
-              )
-            ) :
-            core.void
-        )
-      )
-  })
 
 /* @internal */
 export const reduceEffect = dual<

package/src/internal/version.ts

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