effect 2.1.2 → 2.2.0

package/src/FiberMap.ts

@@ -7,11 +7,13 @@ import type { NoSuchElementException } from "./Cause.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberId from "./FiberId.js"
 import { dual } from "./Function.js"
+import type { FiberMap } from "./index.js"
 import * as Inspectable from "./Inspectable.js"
 import * as MutableHashMap from "./MutableHashMap.js"
 import * as Option from "./Option.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
+import * as Runtime from "./Runtime.js"
 
 /**
  * @since 2.0.0
@@ -98,6 +100,26 @@ const unsafeMake = <K, E = unknown, A = unknown>(): FiberMap<K, E, A> => {
 export const make = <K, E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberMap<K, E, A>> =>
   Effect.acquireRelease(Effect.sync(() => unsafeMake<K, E, A>()), clear)
 
+/**
+ * Create an Effect run function that is backed by a FiberMap.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
+  Scope.Scope | R,
+  never,
+  <XE extends E, XA extends A>(
+    key: K,
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> =>
+  Effect.flatMap(
+    make<K, E, A>(),
+    (self) => runtime(self)<R>()
+  )
+
 /**
  * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
  * If the key already exists in the FiberMap, the previous fiber will be interrupted.
@@ -263,30 +285,89 @@ export const clear = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<never, ne
  * @categories combinators
  */
 export const run: {
-  <K, E, A, R, XE extends E, XA extends A>(
-    key: K,
-    effect: Effect.Effect<R, XE, XA>
-  ): (self: FiberMap<K, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-  <K, E, A, R, XE extends E, XA extends A>(
+  <K, E, A>(
     self: FiberMap<K, E, A>,
-    key: K,
-    effect: Effect.Effect<R, XE, XA>
-  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-} = dual<
-  <K, E, A, R, XE extends E, XA extends A>(
-    key: K,
+    key: K
+  ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<R, XE, XA>
-  ) => (self: FiberMap<K, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>,
+  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
   <K, E, A, R, XE extends E, XA extends A>(
     self: FiberMap<K, E, A>,
     key: K,
     effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
->(3, (self, key, effect) =>
-  Effect.tap(
+  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+} = function() {
+  if (arguments.length === 2) {
+    const self = arguments[0] as FiberMap<any>
+    const key = arguments[1]
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.tap(
+        Effect.forkDaemon(effect),
+        (fiber) => set(self, key, fiber)
+      )
+  }
+  const self = arguments[0] as FiberMap<any>
+  const key = arguments[1]
+  const effect = arguments[2] as Effect.Effect<any, any, any>
+  return Effect.tap(
     Effect.forkDaemon(effect),
     (fiber) => set(self, key, fiber)
-  ))
+  ) as any
+}
+
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
+ *
+ * @example
+ * import { Context, Effect, FiberMap } from "effect"
+ *
+ * interface Users {
+ *   readonly _: unique symbol
+ * }
+ * const Users = Context.Tag<Users, {
+ *    getAll: Effect.Effect<never, never, Array<unknown>>
+ * }>()
+ *
+ * Effect.gen(function*(_) {
+ *   const map = yield* _(FiberMap.make<string>())
+ *   const run = yield* _(FiberMap.runtime(map)<Users>())
+ *
+ *   // run some effects and add the fibers to the map
+ *   run("effect-a", Effect.andThen(Users, _ => _.getAll))
+ *   run("effect-b", Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ *   Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const runtime: <K, E, A>(
+  self: FiberMap<K, E, A>
+) => <R>() => Effect.Effect<
+  R,
+  never,
+  <XE extends E, XA extends A>(
+    key: K,
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> = <K, E, A>(self: FiberMap<K, E, A>) => <R>() =>
+  Effect.map(
+    Effect.runtime<R>(),
+    (runtime) => {
+      const runFork = Runtime.runFork(runtime)
+      return <XE extends E, XA extends A>(
+        key: K,
+        effect: Effect.Effect<R, XE, XA>,
+        options?: Runtime.RunForkOptions | undefined
+      ) => {
+        const fiber = runFork(effect, options)
+        unsafeSet(self, key, fiber)
+        return fiber
+      }
+    }
+  )
 
 /**
  * @since 2.0.0

package/src/FiberSet.ts

@@ -8,6 +8,7 @@ import { dual } from "./Function.js"
 import * as Inspectable from "./Inspectable.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
+import * as Runtime from "./Runtime.js"
 
 /**
  * @since 2.0.0
@@ -94,6 +95,25 @@ const unsafeMake = <E = unknown, A = unknown>(): FiberSet<E, A> => {
 export const make = <E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberSet<E, A>> =>
   Effect.acquireRelease(Effect.sync(() => unsafeMake<E, A>()), clear)
 
+/**
+ * Create an Effect run function that is backed by a FiberSet.
+ *
+ * @since 2.0.0
+ * @categories constructors
+ */
+export const makeRuntime = <R, E = unknown, A = unknown>(): Effect.Effect<
+  Scope.Scope | R,
+  never,
+  <XE extends E, XA extends A>(
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> =>
+  Effect.flatMap(
+    make<E, A>(),
+    (self) => runtime(self)<R>()
+  )
+
 /**
  * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
  *
@@ -165,26 +185,79 @@ export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<never, never, v
  * @categories combinators
  */
 export const run: {
-  <E, A, R, XE extends E, XA extends A>(
+  <E, A>(self: FiberSet<E, A>): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<R, XE, XA>
-  ): (self: FiberSet<E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
   <E, A, R, XE extends E, XA extends A>(
     self: FiberSet<E, A>,
     effect: Effect.Effect<R, XE, XA>
   ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-} = dual<
-  <E, A, R, XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>
-  ) => (self: FiberSet<E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>,
-  <E, A, R, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
->(2, (self, effect) =>
-  Effect.tap(
+} = function() {
+  const self = arguments[0] as FiberSet<any>
+  if (arguments.length === 1) {
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.tap(
+        Effect.forkDaemon(effect),
+        (fiber) => add(self, fiber)
+      )
+  }
+  const effect = arguments[1] as Effect.Effect<any, any, any>
+  return Effect.tap(
     Effect.forkDaemon(effect),
     (fiber) => add(self, fiber)
-  ))
+  ) as any
+}
+
+/**
+ * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
+ *
+ * @example
+ * import { Context, Effect, FiberSet } from "effect"
+ *
+ * interface Users {
+ *   readonly _: unique symbol
+ * }
+ * const Users = Context.Tag<Users, {
+ *    getAll: Effect.Effect<never, never, Array<unknown>>
+ * }>()
+ *
+ * Effect.gen(function*(_) {
+ *   const set = yield* _(FiberSet.make())
+ *   const run = yield* _(FiberSet.runtime(set)<Users>())
+ *
+ *   // run some effects and add the fibers to the set
+ *   run(Effect.andThen(Users, _ => _.getAll))
+ * }).pipe(
+ *   Effect.scoped // The fibers will be interrupted when the scope is closed
+ * )
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const runtime: <E, A>(
+  self: FiberSet<E, A>
+) => <R>() => Effect.Effect<
+  R,
+  never,
+  <XE extends E, XA extends A>(
+    effect: Effect.Effect<R, XE, XA>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<XE, XA>
+> = <E, A>(self: FiberSet<E, A>) => <R>() =>
+  Effect.map(
+    Effect.runtime<R>(),
+    (runtime) => {
+      const runFork = Runtime.runFork(runtime)
+      return <XE extends E, XA extends A>(
+        effect: Effect.Effect<R, XE, XA>,
+        options?: Runtime.RunForkOptions | undefined
+      ) => {
+        const fiber = runFork(effect, options)
+        unsafeAdd(self, fiber)
+        return fiber
+      }
+    }
+  )
 
 /**
  * @since 2.0.0

package/src/internal/fiberId.ts

@@ -38,12 +38,13 @@ export type OP_COMPOSITE = typeof OP_COMPOSITE
 /** @internal */
 class None implements FiberId.None {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
-  readonly _tag = OP_NONE;
+  readonly _tag = OP_NONE
+  readonly _hash: number
+  constructor() {
+    this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}`)
+  }
   [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(FiberIdSymbolKey),
-      Hash.combine(Hash.hash(this._tag))
-    )
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) && that._tag === OP_NONE
@@ -66,17 +67,15 @@ class None implements FiberId.None {
 class Runtime implements FiberId.Runtime {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
   readonly _tag = OP_RUNTIME
+  readonly _hash: number
   constructor(
     readonly id: number,
     readonly startTimeMillis: number
-  ) {}
+  ) {
+    this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`)
+  }
   [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(FiberIdSymbolKey),
-      Hash.combine(Hash.hash(this._tag)),
-      Hash.combine(Hash.hash(this.id)),
-      Hash.combine(Hash.hash(this.startTimeMillis))
-    )
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) &&
@@ -104,18 +103,20 @@ class Runtime implements FiberId.Runtime {
 class Composite implements FiberId.Composite {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
   readonly _tag = OP_COMPOSITE
+  readonly _hash: number
   constructor(
     readonly left: FiberId.FiberId,
     readonly right: FiberId.FiberId
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(FiberIdSymbolKey),
-      Hash.combine(Hash.hash(this._tag)),
+  ) {
+    this._hash = pipe(
+      Hash.string(`${FiberIdSymbolKey}-${this._tag}`),
       Hash.combine(Hash.hash(this.left)),
       Hash.combine(Hash.hash(this.right))
     )
   }
+  [Hash.symbol](): number {
+    return this._hash
+  }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) &&
       that._tag === OP_COMPOSITE &&

package/src/internal/schedule.ts

@@ -116,18 +116,21 @@ class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, I
           core.flatMap((now) =>
             pipe(
               core.suspend(() => this.schedule.step(now, input, state)),
-              core.flatMap(([state, out, decision]) =>
-                ScheduleDecision.isDone(decision) ?
-                  pipe(
-                    ref.set(this.ref, [Option.some(out), state] as const),
-                    core.zipRight(core.fail(Option.none()))
-                  ) :
-                  pipe(
-                    ref.set(this.ref, [Option.some(out), state] as const),
-                    core.zipRight(effect.sleep(Duration.millis(Intervals.start(decision.intervals) - now))),
-                    core.as(out)
-                  )
-              )
+              core.flatMap(([state, out, decision]) => {
+                const setState = ref.set(this.ref, [Option.some(out), state] as const)
+                if (ScheduleDecision.isDone(decision)) {
+                  return core.zipRight(setState, core.fail(Option.none()))
+                }
+                const millis = Intervals.start(decision.intervals) - now
+                if (millis <= 0) {
+                  return core.as(setState, out)
+                }
+                return pipe(
+                  setState,
+                  core.zipRight(effect.sleep(Duration.millis(millis))),
+                  core.as(out)
+                )
+              })
             )
           )
         )

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.1.2"
+export const moduleVersion = "2.2.0"