effect 3.7.2 → 3.8.0

package/src/internal/core.ts

@@ -43,7 +43,7 @@ import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
-import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
+import { CommitPrototype, effectVariance, StructuralCommitPrototype } from "./effectable.js"
 import { getBugErrorMessage } from "./errors.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
@@ -51,7 +51,6 @@ import * as DeferredOpCodes from "./opCodes/deferred.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as _runtimeFlags from "./runtimeFlags.js"
 import { SingleShotGen } from "./singleShotGen.js"
-import * as internalTracer from "./tracer.js"
 
 // -----------------------------------------------------------------------------
 // Effect
@@ -517,9 +516,7 @@ export const unsafeAsync = <A, E = never, R = never>(
     cancelerRef = register(resume)
   }
   effect.effect_instruction_i1 = blockingOn
-  return cancelerRef !== undefined ?
-    onInterrupt(effect, (_) => cancelerRef!) :
-    effect
+  return onInterrupt(effect, (_) => isEffect(cancelerRef) ? cancelerRef : void_)
 }
 
 /* @internal */
@@ -1684,7 +1681,7 @@ const fiberRefVariance = {
 
 /* @internal */
 export const fiberRefGet = <A>(self: FiberRef.FiberRef<A>): Effect.Effect<A> =>
-  fiberRefModify(self, (a) => [a, a] as const)
+  withFiberRuntime((fiber) => exitSucceed(fiber.getFiberRef(self)))
 
 /* @internal */
 export const fiberRefGetAndSet = dual<
@@ -1956,18 +1953,22 @@ export const fiberRefUnsafeMakePatch = <Value, Patch>(
     readonly fork: Patch
     readonly join?: ((oldV: Value, newV: Value) => Value) | undefined
   }
-): FiberRef.FiberRef<Value> => ({
-  [FiberRefTypeId]: fiberRefVariance,
-  initial,
-  diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
-  combine: (first, second) => options.differ.combine(first as Patch, second as Patch),
-  patch: (patch) => (oldValue) => options.differ.patch(patch as Patch, oldValue),
-  fork: options.fork,
-  join: options.join ?? ((_, n) => n),
-  pipe() {
-    return pipeArguments(this, arguments)
+): FiberRef.FiberRef<Value> => {
+  const _fiberRef = {
+    ...CommitPrototype,
+    [FiberRefTypeId]: fiberRefVariance,
+    initial,
+    commit() {
+      return fiberRefGet(this)
+    },
+    diff: (oldValue: Value, newValue: Value) => options.differ.diff(oldValue, newValue),
+    combine: (first: Patch, second: Patch) => options.differ.combine(first, second),
+    patch: (patch: Patch) => (oldValue: Value) => options.differ.patch(patch, oldValue),
+    fork: options.fork,
+    join: options.join ?? ((_, n) => n)
   }
-})
+  return _fiberRef
+}
 
 /** @internal */
 export const fiberRefUnsafeMakeRuntimeFlags = (
@@ -2788,14 +2789,18 @@ const exitCollectAllInternal = <A, E>(
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const deferredUnsafeMake = <A, E = never>(fiberId: FiberId.FiberId): Deferred.Deferred<A, E> => ({
-  [deferred.DeferredTypeId]: deferred.deferredVariance,
-  state: MutableRef.make(deferred.pending([])),
-  blockingOn: fiberId,
-  pipe() {
-    return pipeArguments(this, arguments)
+export const deferredUnsafeMake = <A, E = never>(fiberId: FiberId.FiberId): Deferred.Deferred<A, E> => {
+  const _deferred = {
+    ...CommitPrototype,
+    [deferred.DeferredTypeId]: deferred.deferredVariance,
+    state: MutableRef.make(deferred.pending<A, E>([])),
+    commit() {
+      return deferredAwait(this)
+    },
+    blockingOn: fiberId
   }
-})
+  return _deferred
+}
 
 /* @internal */
 export const deferredMake = <A, E = never>(): Effect.Effect<Deferred.Deferred<A, E>> =>
@@ -2966,7 +2971,7 @@ const deferredInterruptJoiner = <A, E>(
 // Context
 // -----------------------------------------------------------------------------
 
-const constContext = fiberRefGet(currentContext)
+const constContext = withFiberRuntime((fiber) => exitSucceed(fiber.currentContext))
 
 /* @internal */
 export const context = <R>(): Effect.Effect<Context.Context<R>, never, R> => constContext as any
@@ -3021,9 +3026,7 @@ export const mapInputContext = dual<
 
 /** @internal */
 export const currentSpanFromFiber = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Option.Option<Tracer.Span> => {
-  const span = fiber.getFiberRef(currentContext).unsafeMap.get(internalTracer.spanTag.key) as
-    | Tracer.AnySpan
-    | undefined
+  const span = fiber.currentSpan
   return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
 }
 

package/src/internal/defaultServices/console.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import type * as Console from "../../Console.js"
 import * as Context from "../../Context.js"
 import * as core from "../core.js"

package/src/internal/defaultServices.ts

@@ -47,9 +47,14 @@ export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> =>
   return clockWith((clock) => clock.sleep(decodedDuration))
 }
 
+/** @internal */
+export const defaultServicesWith = <A, E, R>(
+  f: (services: Context.Context<DefaultServices.DefaultServices>) => Effect.Effect<A, E, R>
+) => core.withFiberRuntime<A, E, R>((fiber) => f(fiber.currentDefaultServices))
+
 /** @internal */
 export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, clock.clockTag)))
+  defaultServicesWith((services) => f(services.unsafeMap.get(clock.clockTag.key)))
 
 /** @internal */
 export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)
@@ -83,10 +88,7 @@ export const withConfigProvider = dual<
 export const configProviderWith = <A, E, R>(
   f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> =>
-  core.fiberRefGetWith(
-    currentServices,
-    (services) => f(Context.get(services, configProvider.configProviderTag))
-  )
+  defaultServicesWith((services) => f(services.unsafeMap.get(configProvider.configProviderTag.key)))
 
 /** @internal */
 export const config = <A>(config: Config.Config<A>) => configProviderWith((_) => _.load(config))
@@ -98,10 +100,7 @@ export const configOrDie = <A>(config: Config.Config<A>) => core.orDie(configPro
 
 /** @internal */
 export const randomWith = <A, E, R>(f: (random: Random.Random) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  core.fiberRefGetWith(
-    currentServices,
-    (services) => f(Context.get(services, random.randomTag))
-  )
+  defaultServicesWith((services) => f(services.unsafeMap.get(random.randomTag.key)))
 
 /** @internal */
 export const withRandom = dual<
@@ -151,7 +150,7 @@ export const choice = <Self extends Iterable<unknown>>(
 
 /** @internal */
 export const tracerWith = <A, E, R>(f: (tracer: Tracer.Tracer) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, tracer.tracerTag)))
+  defaultServicesWith((services) => f(services.unsafeMap.get(tracer.tracerTag.key)))
 
 /** @internal */
 export const withTracer = dual<

package/src/internal/effect/circular.ts

@@ -2,6 +2,7 @@ import type * as Cause from "../../Cause.js"
 import type * as Deferred from "../../Deferred.js"
 import * as Duration from "../../Duration.js"
 import type * as Effect from "../../Effect.js"
+import * as Effectable from "../../Effectable.js"
 import * as Equal from "../../Equal.js"
 import type { Equivalence } from "../../Equivalence.js"
 import * as Exit from "../../Exit.js"
@@ -92,6 +93,17 @@ class Semaphore {
         (permits) => fiberRuntime.ensuring(restore(self), this.release(permits))
       )
     )
+
+  readonly withPermitsIfAvailable = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
+    core.uninterruptibleMask((restore) =>
+      core.suspend(() => {
+        if (this.free < n) {
+          return effect.succeedNone
+        }
+        this.taken += n
+        return fiberRuntime.ensuring(restore(effect.asSome(self)), this.release(n))
+      })
+    )
 }
 
 /** @internal */
@@ -100,6 +112,67 @@ export const unsafeMakeSemaphore = (permits: number): Semaphore => new Semaphore
 /** @internal */
 export const makeSemaphore = (permits: number) => core.sync(() => unsafeMakeSemaphore(permits))
 
+class Latch implements Effect.Latch {
+  waiters: Array<(_: Effect.Effect<void>) => void> = []
+  scheduled = false
+  constructor(private isOpen: boolean) {}
+
+  private unsafeSchedule(fiber: Fiber.RuntimeFiber<void>) {
+    if (this.scheduled || this.waiters.length === 0) {
+      return core.void
+    }
+    this.scheduled = true
+    fiber.currentScheduler.scheduleTask(this.flushWaiters, fiber.getFiberRef(core.currentSchedulingPriority))
+    return core.void
+  }
+  private flushWaiters = () => {
+    this.scheduled = false
+    const waiters = this.waiters
+    this.waiters = []
+    for (let i = 0; i < waiters.length; i++) {
+      waiters[i](core.exitVoid)
+    }
+  }
+
+  open = core.withFiberRuntime<void>((fiber) => {
+    if (this.isOpen) {
+      return core.void
+    }
+    this.isOpen = true
+    return this.unsafeSchedule(fiber)
+  })
+  release = core.withFiberRuntime<void>((fiber) => {
+    if (this.isOpen) {
+      return core.void
+    }
+    return this.unsafeSchedule(fiber)
+  })
+  await = core.unsafeAsync<void>((resume) => {
+    if (this.isOpen) {
+      return resume(core.void)
+    }
+    this.waiters.push(resume)
+    return core.sync(() => {
+      const index = this.waiters.indexOf(resume)
+      if (index !== -1) {
+        this.waiters.splice(index, 1)
+      }
+    })
+  })
+  close = core.sync(() => {
+    this.isOpen = false
+  })
+  whenOpen = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
+    return core.zipRight(this.await, self)
+  }
+}
+
+/** @internal */
+export const unsafeMakeLatch = (open?: boolean | undefined): Effect.Latch => new Latch(open ?? false)
+
+/** @internal */
+export const makeLatch = (open?: boolean | undefined) => core.sync(() => unsafeMakeLatch(open))
+
 /** @internal */
 export const awaitAllChildren = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   ensuringChildren(self, fiberRuntime.fiberAwaitAll)
@@ -571,18 +644,21 @@ export const synchronizedVariance = {
 }
 
 /** @internal */
-class SynchronizedImpl<in out A> implements Synchronized.SynchronizedRef<A> {
+class SynchronizedImpl<in out A> extends Effectable.Class<A> implements Synchronized.SynchronizedRef<A> {
   readonly [SynchronizedTypeId] = synchronizedVariance
   readonly [internalRef.RefTypeId] = internalRef.refVariance
-  readonly [Readable.TypeId]: Readable.TypeId
+  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
   constructor(
     readonly ref: Ref.Ref<A>,
     readonly withLock: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   ) {
-    this[Readable.TypeId] = Readable.TypeId
+    super()
     this.get = internalRef.get(this.ref)
   }
   readonly get: Effect.Effect<A>
+  commit() {
+    return this.get
+  }
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return this.modifyEffect((a) => core.succeed(f(a)))
   }
@@ -594,9 +670,6 @@ class SynchronizedImpl<in out A> implements Synchronized.SynchronizedRef<A> {
       )
     )
   }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
 }
 
 /** @internal */
@@ -664,6 +737,10 @@ export const zipWithFiber = dual<
     f: (a: A, b: B) => C
   ) => Fiber.Fiber<C, E | E2>
 >(3, (self, that, f) => ({
+  ...Effectable.CommitPrototype,
+  commit() {
+    return internalFiber.join(this)
+  },
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => pipe(self.id(), FiberId.getOrElse(that.id())),
   await: pipe(

package/src/internal/fiber.ts

@@ -14,6 +14,7 @@ import * as order from "../Order.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import * as core from "./core.js"
+import * as effectable from "./effectable.js"
 import * as fiberScope from "./fiberScope.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 
@@ -76,15 +77,23 @@ export const children = <A, E>(
 ): Effect.Effect<Array<Fiber.RuntimeFiber<any, any>>> => self.children
 
 /** @internal */
-export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => ({
-  ...fiberProto,
-  id: () => FiberId.none,
-  await: core.succeed(exit),
-  children: core.succeed([]),
-  inheritAll: core.void,
-  poll: core.succeed(Option.some(exit)),
-  interruptAsFork: () => core.void
-})
+export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => {
+  const _fiber = {
+    ...effectable.CommitPrototype,
+    commit() {
+      return join(this)
+    },
+    ...fiberProto,
+    id: () => FiberId.none,
+    await: core.succeed(exit),
+    children: core.succeed([]),
+    inheritAll: core.void,
+    poll: core.succeed(Option.some(exit)),
+    interruptAsFork: () => core.void
+  }
+
+  return _fiber
+}
 
 /** @internal */
 export const dump = <A, E>(self: Fiber.RuntimeFiber<A, E>): Effect.Effect<Fiber.Fiber.Dump> =>
@@ -148,25 +157,32 @@ export const map = dual<
 export const mapEffect = dual<
   <A, A2, E2>(f: (a: A) => Effect.Effect<A2, E2>) => <E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A2, E | E2>,
   <A, E, A2, E2>(self: Fiber.Fiber<A, E>, f: (a: A) => Effect.Effect<A2, E2>) => Fiber.Fiber<A2, E | E2>
->(2, (self, f) => ({
-  ...fiberProto,
-  id: () => self.id(),
-  await: core.flatMap(self.await, Exit.forEachEffect(f)),
-  children: self.children,
-  inheritAll: self.inheritAll,
-  poll: core.flatMap(self.poll, (result) => {
-    switch (result._tag) {
-      case "None":
-        return core.succeed(Option.none())
-      case "Some":
-        return pipe(
-          Exit.forEachEffect(result.value, f),
-          core.map(Option.some)
-        )
-    }
-  }),
-  interruptAsFork: (id) => self.interruptAsFork(id)
-}))
+>(2, (self, f) => {
+  const _fiber = {
+    ...effectable.CommitPrototype,
+    commit() {
+      return join(this)
+    },
+    ...fiberProto,
+    id: () => self.id(),
+    await: core.flatMap(self.await, Exit.forEachEffect(f)),
+    children: self.children,
+    inheritAll: self.inheritAll,
+    poll: core.flatMap(self.poll, (result) => {
+      switch (result._tag) {
+        case "None":
+          return core.succeed(Option.none())
+        case "Some":
+          return pipe(
+            Exit.forEachEffect(result.value, f),
+            core.map(Option.some)
+          )
+      }
+    }),
+    interruptAsFork: (id: FiberId.FiberId) => self.interruptAsFork(id)
+  }
+  return _fiber
+})
 
 /** @internal */
 export const mapFiber = dual<
@@ -212,7 +228,11 @@ export const match = dual<
 })
 
 /** @internal */
-export const never: Fiber.Fiber<never> = {
+const _never = {
+  ...effectable.CommitPrototype,
+  commit() {
+    return join(this)
+  },
   ...fiberProto,
   id: () => FiberId.none,
   await: core.never,
@@ -222,11 +242,18 @@ export const never: Fiber.Fiber<never> = {
   interruptAsFork: () => core.never
 }
 
+/** @internal */
+export const never: Fiber.Fiber<never> = _never
+
 /** @internal */
 export const orElse = dual<
   <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<A | A2, E | E2>,
   <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<A | A2, E | E2>
 >(2, (self, that) => ({
+  ...effectable.CommitPrototype,
+  commit() {
+    return join(this)
+  },
   ...fiberProto,
   id: () => FiberId.getOrElse(self.id(), that.id()),
   await: core.zipWith(

package/src/internal/fiberRefs.ts

@@ -33,8 +33,7 @@ export class FiberRefsImpl implements FiberRefs.FiberRefs {
       FiberRef.FiberRef<any>,
       Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>
     >
-  ) {
-  }
+  ) {}
   pipe() {
     return pipeArguments(this, arguments)
   }