effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/internal/graph.ts

@@ -7,7 +7,12 @@ import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
 
 /** @internal */
-export const TypeId = "~effect/collections/Graph"
+export const TypeId = "~effect/Graph"
+
+/** @internal */
+export const isGraph = <N = unknown, E = unknown, T extends Graph.Kind = Graph.Kind, U = never>(
+  u: U | Graph.Graph<N, E, T> | Graph.MutableGraph<N, E, T>
+): u is Graph.Graph<N, E, T> | Graph.MutableGraph<N, E, T> => hasProperty(u, TypeId)
 
 /** @internal */
 export interface GraphImpl<in out N, in out E, T extends Graph.Kind>

package/src/internal/hashMap.ts

@@ -16,7 +16,7 @@ import * as Result from "../Result.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
-export const HashMapTypeId = "~effect/collections/HashMap"
+export const HashMapTypeId = "~effect/HashMap"
 
 /** @internal */
 export type HashMapTypeId = typeof HashMapTypeId
@@ -410,8 +410,10 @@ class CollisionNode<K, V> extends Node<K, V> {
     return new CollisionNode(edit, this.hash, newEntries)
   }
 
-  iterator(): Iterator<[K, V]> {
-    return this.entries[Symbol.iterator]()
+  *iterator(): Iterator<[K, V]> {
+    for (const [key, value] of this.entries) {
+      yield [key, value]
+    }
   }
 
   [Symbol.iterator](): Iterator<[K, V]> {

package/src/internal/hashSet.ts

@@ -13,7 +13,7 @@ import { hasProperty } from "../Predicate.ts"
 import * as HashMap from "./hashMap.ts"
 
 /** @internal */
-export const HashSetTypeId = "~effect/collections/HashSet"
+export const HashSetTypeId = "~effect/HashSet"
 
 /** @internal */
 export type HashSetTypeId = typeof HashSetTypeId

package/src/internal/matcher.ts

@@ -17,7 +17,22 @@ import * as Result from "../Result.ts"
 import type { Unify } from "../Unify.ts"
 
 /** @internal */
-export const TypeId = "~effect/match/Match/Matcher"
+export const TypeId = "~effect/Match/Matcher"
+
+/** @internal */
+export type Contextual<P, Fallback> = [P] extends [never] ? Fallback : P
+
+type TagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]: (_: Extract<R, Record<D, Tag>>) => Ret
+}
+
+type PartialTagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]?: ((_: Extract<R, Record<D, Tag>>) => Ret) | undefined
+}
+
+type ValueTagHandlers<I> = {
+  readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any
+}
 
 const TypeMatcherProto: Omit<TypeMatcher<any, any, any, any, any, any>, "cases" | "select"> = {
   [TypeId]: {
@@ -220,23 +235,31 @@ export const valueTags: {
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(fields: P): (input: I) => Unify<ReturnType<P[keyof P]>>
+  >(
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): (input: I) => Unify<ReturnType<P[keyof P]>>
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>>
+  >(
+    input: I,
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): Unify<ReturnType<P[keyof P]>>
 } = dual(
   2,
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>> => {
+  >(
+    input: I,
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): Unify<ReturnType<P[keyof P]>> => {
     const match: any = tagsExhaustive(fields as any)(makeTypeMatcher(identity, []))
     return match(input)
   }
@@ -413,14 +436,10 @@ export const discriminators = <D extends string>(field: D) =>
   R,
   Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]?:
-        | ((_: Extract<R, Record<D, Tag>>) => Ret)
-        | undefined
-    }
+    & PartialTagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, PartialTagHandlers<D, R, Ret>>
 ) => {
   const predicate = makeWhen(
     (arg: any) => arg != null && Object.hasOwn(fields, arg[field]),
@@ -446,14 +465,10 @@ export const discriminatorsExhaustive: <D extends string>(
   R,
   Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]: (
-        _: Extract<R, Record<D, Tag>>
-      ) => Ret
-    }
+    & TagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, TagHandlers<D, R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>

package/src/internal/metric.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const FiberRuntimeMetricsKey = "effect/observability/Metric/FiberRuntimeMetricsKey"
+export const FiberRuntimeMetricsKey = "effect/Metric/FiberRuntimeMetrics"

package/src/internal/option.ts

@@ -10,7 +10,7 @@ import { hasProperty } from "../Predicate.ts"
 import { SingleShotGen } from "../Utils.ts"
 import { PipeInspectableProto } from "./core.ts"
 
-const TypeId = "~effect/data/Option"
+const TypeId = "~effect/Option"
 
 const CommonProto = {
   [TypeId]: {
@@ -91,8 +91,10 @@ export const isSome = <A>(fa: Option.Option<A>): fa is Option.Some<A> => fa._tag
 export const none: Option.Option<never> = Object.create(NoneProto)
 
 /** @internal */
-export const some = <A>(value: A): Option.Option<A> => {
-  const a = Object.create(SomeProto)
-  a.value = value
-  return a
-}
+const SomeImpl = function(this: any, value: unknown) {
+  this.value = value
+} as unknown as { new<A>(value: A): Option.Option<A>; prototype: any }
+SomeImpl.prototype = SomeProto
+
+/** @internal */
+export const some = <A>(value: A): Option.Option<A> => new SomeImpl(value)

package/src/internal/random.ts

@@ -1,13 +1,8 @@
 import * as Context from "../Context.ts"
+import type { Random as RandomService } from "../Random.ts"
 
 /** @internal */
-export interface Random {
-  nextIntUnsafe(): number
-  nextDoubleUnsafe(): number
-}
-
-/** @internal */
-export const Random: Context.Reference<Random> = Context.Reference<Random>("effect/Random", {
+export const Random: Context.Reference<RandomService> = Context.Reference<RandomService>("effect/Random", {
   defaultValue: () => ({
     nextIntUnsafe() {
       return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
@@ -18,3 +13,21 @@ export const Random: Context.Reference<Random> = Context.Reference<Random>("effe
     }
   })
 })
+
+/** @internal */
+export const nextBetween = (min: number, max: number, draw: number): number => {
+  const value = draw * (max - min) + min
+  if (value !== max || min >= max || !Number.isFinite(max)) {
+    return value
+  }
+  // Rounding can reach the excluded endpoint even for a draw below 1.
+  // Return its immediate predecessor, which is at least min for finite min < max.
+  if (max === 0) {
+    return -Number.MIN_VALUE
+  }
+  const view = new DataView(new ArrayBuffer(8))
+  view.setFloat64(0, max)
+  const bits = view.getBigUint64(0)
+  view.setBigUint64(0, max > 0 ? bits - BigInt(1) : bits + BigInt(1))
+  return view.getFloat64(0)
+}

package/src/internal/rcRef.ts

@@ -116,7 +116,10 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
               self.acquire as Effect.Effect<A, E>,
               Context.add(self.context, Scope.Scope, scope)
             )).pipe(
-              Effect.map((value) => {
+              Effect.flatMap((value) => {
+                if (self.state._tag === "Closed") {
+                  return Effect.interrupt
+                }
                 const state: State.Acquired<A> = {
                   _tag: "Acquired",
                   value,
@@ -126,7 +129,7 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
                   invalidated: false
                 }
                 self.state = state
-                return state
+                return Effect.succeed(state)
               }),
               Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
             )
@@ -149,17 +152,17 @@ export const get = Effect.fnUntraced(function*<A, E>(
     if (state.refCount > 0) {
       return Effect.void
     }
-    if (self.idleTimeToLive === undefined) {
-      self.state = stateEmpty
-      return Scope.close(state.scope, Exit.void)
-    } else if (state.invalidated) {
+    if (self.idleTimeToLive === undefined || state.invalidated) {
+      if (self.state === state) {
+        self.state = stateEmpty
+      }
       return Scope.close(state.scope, Exit.void)
     } else if (!isFinite) {
       return Effect.void
     }
     state.fiber = Effect.sleep(self.idleTimeToLive).pipe(
       Effect.flatMap(() => {
-        if (self.state._tag === "Acquired" && self.state.refCount === 0) {
+        if (self.state === state && state.refCount === 0) {
           self.state = stateEmpty
           return Scope.close(state.scope, Exit.void)
         }

package/src/internal/references.ts

@@ -20,6 +20,7 @@ export const CurrentStackFrame = Context.Reference<StackFrame | undefined>("effe
 
 /** @internal */
 export const TracerEnabled = Context.Reference<boolean>("effect/References/TracerEnabled", {
+  fiberCached: true,
   defaultValue: constTrue
 })
 

package/src/internal/request.ts

@@ -62,7 +62,7 @@ export const requestUnsafe = <A extends Request.Any>(
 ): () => void => {
   const entry = addEntry(options.resolver, self, options.onExit, {
     context: options.context,
-    currentScheduler: Context.get(options.context, Scheduler)
+    cache: { scheduler: Context.get(options.context, Scheduler) }
   })
   return () => removeEntryUnsafe(options.resolver, entry)
 }
@@ -87,7 +87,7 @@ const addEntry = <A extends Request.Any>(
   resume: (exit: Exit<any, any>) => void,
   fiber: {
     readonly context: Context.Context<never>
-    readonly currentScheduler: Scheduler
+    readonly cache: { readonly scheduler: Scheduler }
     readonly id?: number
   }
 ) => {
@@ -105,8 +105,9 @@ const addEntry = <A extends Request.Any>(
     completeUnsafe(effect) {
       if (completed) return
       completed = true
+      // Removed entries still notify resolver hooks, but not their cancelled callers.
+      if (batch && !batch.entrySet.delete(entry)) return
       resume(effect)
-      batch?.entrySet.delete(entry)
     }
   })
   if (resolver.preCheck !== undefined && !resolver.preCheck(entry)) {
@@ -161,7 +162,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.cache.scheduler })
   }
 
   batch.entrySet.add(entry)
@@ -169,7 +170,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.cache.scheduler })
   return entry
 }
 
@@ -184,13 +185,17 @@ const removeEntryUnsafe = <A extends Request.Any>(
   const batch = batchMap.get(key)
   if (!batch) return
 
-  batch.entries.delete(entry)
+  if (!batch.entries.delete(entry)) return
   batch.entrySet.delete(entry)
 
+  let fiber: Fiber<void, unknown> | undefined
   if (batch.entries.size === 0) {
     batchMap.delete(key)
-    batch.fiber?.interruptUnsafe()
+    fiber = batch.fiber
   }
+  // Delay finalizers may enqueue new requests, so complete the removed entry first.
+  entry.completeUnsafe(effect.exitInterrupt())
+  fiber?.interruptUnsafe()
 }
 
 const maybeRemoveEntry = <A extends Request.Any>(

package/src/internal/result.ts

@@ -10,7 +10,7 @@ import { SingleShotGen } from "../Utils.ts"
 import { PipeInspectableProto } from "./core.ts"
 import * as option from "./option.ts"
 
-const TypeId = "~effect/data/Result"
+const TypeId = "~effect/Result"
 
 const CommonProto = {
   [TypeId]: {
@@ -80,18 +80,22 @@ export const isSuccess = <A, E>(result: Result.Result<A, E>): result is Result.S
   result._tag === "Success"
 
 /** @internal */
-export const fail = <E>(failure: E): Result.Result<never, E> => {
-  const a = Object.create(FailureProto)
-  a.failure = failure
-  return a
-}
+const FailureImpl = function(this: any, failure: unknown) {
+  this.failure = failure
+} as unknown as { new<E>(failure: E): Result.Result<never, E>; prototype: any }
+FailureImpl.prototype = FailureProto
 
 /** @internal */
-export const succeed = <A>(success: A): Result.Result<A> => {
-  const a = Object.create(SuccessProto)
-  a.success = success
-  return a
-}
+export const fail = <E>(failure: E): Result.Result<never, E> => new FailureImpl(failure)
+
+/** @internal */
+const SuccessImpl = function(this: any, success: unknown) {
+  this.success = success
+} as unknown as { new<A>(success: A): Result.Result<A>; prototype: any }
+SuccessImpl.prototype = SuccessProto
+
+/** @internal */
+export const succeed = <A>(success: A): Result.Result<A> => new SuccessImpl(success)
 
 /** @internal */
 export const getFailure = <A, E>(self: Result.Result<A, E>): Option<E> =>

package/src/internal/schema/annotations.ts

@@ -70,15 +70,15 @@ export const annotationExcludedKeys = new Set([
   SENTINELS_ANNOTATION_KEY,
   STRUCTURAL_ANNOTATION_KEY,
   "representation",
-  "arbitrary",
+  "arbitraryConstraint",
   "brands",
   "toJsonSchema",
   "toCode",
-  "toArbitrary",
   "toEquivalence",
   "toFormatter",
   "toCodec",
   "toCodecJson",
   "toCodecStringTree",
-  "toCodecIso"
+  "toCodecIso",
+  "toCodecArbitrary"
 ])