effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/Terminal.ts

@@ -121,7 +121,7 @@ const QuitErrorTypeId = "effect/platform/Terminal/QuitError"
  * @category errors
  * @since 4.0.0
  */
-export class QuitError extends Schema.ErrorClass<QuitError>("QuitError")({
+export class QuitError extends Schema.Error<QuitError>("QuitError")({
   _tag: Schema.tag("QuitError")
 }) {
   /**

package/src/Tuple.ts

@@ -43,7 +43,8 @@ import type { Apply, Lambda } from "./Struct.ts"
  * @category constructors
  * @since 2.0.0
  */
-export const make = <Elements extends ReadonlyArray<unknown>>(...elements: Elements): Elements => elements
+export const make = <const Elements extends ReadonlyArray<unknown>>(...elements: [...Elements]): [...Elements] =>
+  elements
 
 type Indices<T extends ReadonlyArray<unknown>> = Exclude<Partial<T>["length"], T["length"]>
 
@@ -138,7 +139,9 @@ type _BuildTuple<
     [...I, unknown]
   >
 
-type PickTuple<T extends ReadonlyArray<unknown>, K> = _BuildTuple<T, K>
+type PickTuple<T extends ReadonlyArray<unknown>, I extends ReadonlyArray<Indices<T>>> = {
+  -readonly [K in keyof I]: T[I[K] & keyof T]
+}
 
 /**
  * Creates a new tuple containing only the elements at the specified indices.
@@ -189,7 +192,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I>
   /**
    * Creates a new tuple containing only the elements at the specified indices.
    *
@@ -214,7 +217,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I>
 } = dual(
   2,
   <const T extends ReadonlyArray<unknown>>(

package/src/TxReentrantLock.ts

@@ -266,24 +266,24 @@ export const acquireWrite = (self: TxReentrantLock): Effect.Effect<number> =>
  * @category mutations
  * @since 2.0.0
  */
-export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
-  Effect.withFiber((fiber) =>
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      const fiberId = fiber.id
-      const currentCount = Option.getOrElse(HashMap.get(state.readers, fiberId), () => 0)
+const releaseReadFor = (self: TxReentrantLock, fiberId: number): Effect.Effect<number> =>
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
+    const currentCount = Option.getOrElse(HashMap.get(state.readers, fiberId), () => 0)
 
-      if (currentCount <= 0) return 0
+    if (currentCount <= 0) return 0
 
-      const newCount = currentCount - 1
-      const newReaders = newCount === 0
-        ? HashMap.remove(state.readers, fiberId)
-        : HashMap.set(state.readers, fiberId, newCount)
+    const newCount = currentCount - 1
+    const newReaders = newCount === 0
+      ? HashMap.remove(state.readers, fiberId)
+      : HashMap.set(state.readers, fiberId, newCount)
 
-      yield* TxRef.set(self.stateRef, { ...state, readers: newReaders })
-      return newCount
-    }).pipe(Effect.tx)
-  )
+    yield* TxRef.set(self.stateRef, { ...state, readers: newReaders })
+    return newCount
+  }).pipe(Effect.tx)
+
+export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
+  Effect.withFiber((fiber) => releaseReadFor(self, fiber.id))
 
 /**
  * Releases one write lock held by the current fiber.
@@ -313,23 +313,23 @@ export const releaseRead = (self: TxReentrantLock): Effect.Effect<number> =>
  * @category mutations
  * @since 2.0.0
  */
-export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
-  Effect.withFiber((fiber) =>
-    Effect.gen(function*() {
-      const state = yield* TxRef.get(self.stateRef)
-      const fiberId = fiber.id
+const releaseWriteFor = (self: TxReentrantLock, fiberId: number): Effect.Effect<number> =>
+  Effect.gen(function*() {
+    const state = yield* TxRef.get(self.stateRef)
 
-      if (Option.isNone(state.writer) || state.writer.value[0] !== fiberId) return 0
+    if (Option.isNone(state.writer) || state.writer.value[0] !== fiberId) return 0
 
-      const newCount = state.writer.value[1] - 1
-      const newWriter = newCount <= 0
-        ? Option.none<readonly [number, number]>()
-        : Option.some([fiberId, newCount] as const)
+    const newCount = state.writer.value[1] - 1
+    const newWriter = newCount <= 0
+      ? Option.none<readonly [number, number]>()
+      : Option.some([fiberId, newCount] as const)
 
-      yield* TxRef.set(self.stateRef, { ...state, writer: newWriter })
-      return newCount
-    }).pipe(Effect.tx)
-  )
+    yield* TxRef.set(self.stateRef, { ...state, writer: newWriter })
+    return newCount
+  }).pipe(Effect.tx)
+
+export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
+  Effect.withFiber((fiber) => releaseWriteFor(self, fiber.id))
 
 /**
  * Acquires a read lock for the duration of the scope.
@@ -361,9 +361,11 @@ export const releaseWrite = (self: TxReentrantLock): Effect.Effect<number> =>
  * @since 2.0.0
  */
 export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    acquireRead(self),
-    () => releaseRead(self)
+  Effect.withFiber((fiber) =>
+    Effect.acquireRelease(
+      acquireRead(self),
+      () => releaseReadFor(self, fiber.id)
+    )
   )
 
 /**
@@ -396,9 +398,11 @@ export const readLock = (self: TxReentrantLock): Effect.Effect<number, never, Sc
  * @since 2.0.0
  */
 export const writeLock = (self: TxReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    acquireWrite(self),
-    () => releaseWrite(self)
+  Effect.withFiber((fiber) =>
+    Effect.acquireRelease(
+      acquireWrite(self),
+      () => releaseWriteFor(self, fiber.id)
+    )
   )
 
 /**

package/src/internal/dateTime.ts

@@ -221,7 +221,7 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
     return fromDateUnsafe(input) as DateTime.DateTime.PreserveZone<A>
   } else if (typeof input === "object") {
     if ("epochMilliseconds" in input) {
-      return makeUtc(input.epochMilliseconds) as DateTime.DateTime.PreserveZone<A>
+      return fromDateUnsafe(new Date(input.epochMilliseconds)) as DateTime.DateTime.PreserveZone<A>
     }
     const date = new Date(0)
     setPartsDate(date, input)

package/src/internal/executionPlan.ts

@@ -1,47 +1,131 @@
+import * as Duration from "../Duration.ts"
 import type { Effect } from "../Effect.ts"
 import * as Api from "../ExecutionPlan.ts"
-import { dual } from "../Function.ts"
+import type * as Exit from "../Exit.ts"
+import { dual, identity } from "../Function.ts"
 import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
+import { isEffect } from "./core.ts"
 import * as effect from "./effect.ts"
 import * as internalLayer from "./layer.ts"
 import * as internalSchedule from "./schedule.ts"
 
+/** @internal */
+export interface AttemptState {
+  readonly attempt: number
+  readonly stepAttempt: number
+  readonly stepIndex: number
+  readonly startNanos: bigint
+}
+
+/** @internal */
+export interface EventEmitter {
+  readonly begin: Effect<AttemptState, never, any>
+  readonly end: (state: AttemptState, exit: Exit.Exit<any, any>) => Effect<void, never, any>
+}
+
+/** @internal */
+export const makeEventEmitter = (
+  onEvent: (event: Api.Event<any>) => Effect<void, never, any>,
+  currentMetadata: () => Api.Metadata
+): EventEmitter => {
+  let lastStepIndex = -1
+  let stepAttempt = 0
+  return {
+    begin: effect.clockWith((clock) =>
+      effect.suspend(() => {
+        const meta = currentMetadata()
+        if (meta.stepIndex !== lastStepIndex) {
+          lastStepIndex = meta.stepIndex
+          stepAttempt = 0
+        }
+        stepAttempt++
+        const state: AttemptState = {
+          attempt: meta.attempt,
+          stepAttempt,
+          stepIndex: meta.stepIndex,
+          startNanos: clock.monotonicTimeNanosUnsafe()
+        }
+        return effect.as(
+          onEvent({
+            _tag: "AttemptStart",
+            attempt: state.attempt,
+            stepAttempt: state.stepAttempt,
+            stepIndex: state.stepIndex
+          }),
+          state
+        )
+      })
+    ),
+    end: (state, exit) =>
+      effect.clockWith((clock) => {
+        const duration = Duration.nanos(clock.monotonicTimeNanosUnsafe() - state.startNanos)
+        return onEvent(
+          exit._tag === "Success"
+            ? {
+              _tag: "AttemptSuccess",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration
+            }
+            : {
+              _tag: "AttemptFailure",
+              attempt: state.attempt,
+              stepAttempt: state.stepAttempt,
+              stepIndex: state.stepIndex,
+              duration,
+              cause: exit.cause
+            }
+        )
+      })
+  }
+}
+
 /** @internal */
 export const withExecutionPlan: {
-  <Input, Provides, PlanE, PlanR>(
+  <Input, Provides, PlanE, PlanR, RX = never>(
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<Input | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-  <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+  <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX = never>(
     effect: Effect<A, E, R>,
     plan: Api.ExecutionPlan<{
       provides: Provides
       input: Input
       error: PlanE
       requirements: PlanR
-    }>
+    }>,
+    options?: {
+      readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+    }
   ): Effect<
     A,
     E | PlanE,
-    Exclude<R, Provides> | PlanR
+    Exclude<R, Provides> | PlanR | RX
   >
-} = dual(2, <A, E extends Input, R, Provides, Input, PlanE, PlanR>(
+} = dual((args) => isEffect(args[0]), <A, E extends Input, R, Provides, Input, PlanE, PlanR, RX>(
   self: Effect<A, E, R>,
   plan: Api.ExecutionPlan<{
     provides: Provides
     input: Input
     error: PlanE
     requirements: PlanR
-  }>
+  }>,
+  options?: {
+    readonly onEvent?: ((event: Api.Event<E | PlanE>) => Effect<void, never, RX>) | undefined
+  }
 ) =>
   effect.suspend(() => {
     let i = 0
@@ -59,13 +143,24 @@ export const withExecutionPlan: {
         return meta
       })
     )
+    const emitter = options?.onEvent === undefined
+      ? undefined
+      : makeEventEmitter(options.onEvent, () => meta)
+    const instrument: (attempt: Effect<A, any, any>) => Effect<A, any, any> = emitter === undefined
+      ? identity
+      : (attempt) =>
+        effect.uninterruptibleMask((restore) =>
+          effect.flatMap(emitter.begin, (state) => effect.onExit(restore(attempt), (exit) => emitter.end(state, exit)))
+        )
     let result: Result.Result<A, any> | undefined
     return effect.flatMap(
       effect.whileLoop({
         while: () => i < plan.steps.length && (result === undefined || Result.isFailure(result)),
         body() {
           const step = plan.steps[i]
-          let nextEffect: Effect<A, any, any> = provideMeta(internalLayer.provide(self, step.provide as any))
+          let nextEffect: Effect<A, any, any> = provideMeta(
+            instrument(internalLayer.provide(self, step.provide as any))
+          )
           if (result) {
             let attempted = false
             const wrapped = nextEffect

package/src/internal/hashMap.ts

@@ -977,13 +977,8 @@ export const hasBy = dual<
   return false
 })
 
-/** @internal */
-export const set = dual<
-  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
->(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+const setHash = <K, V>(self: HashMap<K, V>, key: K, hash: number, value: V): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const added = { value: false }
 
   // Pass edit context: use current edit if editable, otherwise NaN (never matches any edit)
@@ -1005,6 +1000,14 @@ export const set = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size + (added.value ? 1 : 0))
+}
+
+/** @internal */
+export const set = dual<
+  <K, V>(key: K, value: V) => (self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K, value: V) => HashMap<K, V>
+>(3, <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V> => {
+  return setHash(self, key, Hash.hash(key), value)
 })
 
 /** @internal */
@@ -1104,10 +1107,10 @@ export const modifyHash = dual<
   const updated = f(current)
 
   if (Option.isNone(updated)) {
-    return hasHash(self, key, hash) ? remove(self, key) : self
+    return hasHash(self, key, hash) ? removeHash(self, key, hash) : self
   }
 
-  return set(self, key, updated.value)
+  return setHash(self, key, hash, updated.value)
 })
 
 /** @internal */
@@ -1130,13 +1133,8 @@ export const union = dual<
   return result
 })
 
-/** @internal */
-export const remove = dual<
-  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
-  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
->(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+const removeHash = <K, V>(self: HashMap<K, V>, key: K, hash: number): HashMap<K, V> => {
   const impl = self as HashMapImpl<K, V>
-  const hash = Hash.hash(key)
   const removed = { value: false }
 
   const edit = impl._editable ? impl._edit : NaN
@@ -1157,6 +1155,14 @@ export const remove = dual<
   }
 
   return new HashMapImpl(false, impl._edit, newRoot, impl._size - 1)
+}
+
+/** @internal */
+export const remove = dual<
+  <K>(key: K) => <V>(self: HashMap<K, V>) => HashMap<K, V>,
+  <K, V>(self: HashMap<K, V>, key: K) => HashMap<K, V>
+>(2, <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V> => {
+  return removeHash(self, key, Hash.hash(key))
 })
 
 /** @internal */

package/src/internal/matcher.ts

@@ -124,8 +124,8 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
       return true
     }
   } else if (pattern !== null && typeof pattern === "object") {
-    const keysAndPredicates = Object.entries(pattern).map(
-      ([k, p]) => [k, makePredicate(p)] as const
+    const keysAndPredicates = Reflect.ownKeys(pattern).map(
+      (key) => [key, makePredicate((pattern as any)[key])] as const
     )
     const len = keysAndPredicates.length
 

package/src/internal/schedule.ts

@@ -184,17 +184,17 @@ export const scheduleFrom = dual<
     schedule: Schedule.Schedule<Output, Input, Error, Env>
   ) => <E, R>(
     self: Effect<Input, E, R>
-  ) => Effect<Output, E, R | Env>,
+  ) => Effect<Output, E | Error, R | Env>,
   <Input, E, R, Output, Error, Env>(
     self: Effect<Input, E, R>,
     initial: Input,
     schedule: Schedule.Schedule<Output, Input, Error, Env>
-  ) => Effect<Output, E, R | Env>
+  ) => Effect<Output, E | Error, R | Env>
 >(3, <Input, E, R, Output, Error, Env>(
   self: Effect<Input, E, R>,
   initial: Input,
   schedule: Schedule.Schedule<Output, Input, Error, Env>
-): Effect<Output, E, R | Env> =>
+): Effect<Output, E | Error, R | Env> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
     const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta))
@@ -213,7 +213,7 @@ export const scheduleFrom = dual<
           }) as Effect<never, E, R | Env>
         }
       ),
-      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E)
+      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E | Error)
     )
   }))
 

package/src/internal/schema/annotations.ts

@@ -21,6 +21,9 @@ export const IDENTIFIER_FALLBACK_KEY = "~identifier"
 /** @internal */
 export const SENTINELS_ANNOTATION_KEY = "~sentinels"
 
+/** @internal */
+export const CONSTRUCTOR_ANNOTATION_KEY = "~constructor"
+
 /** @internal */
 export const jsonSchemaAnnotationKeys = [
   "title",

package/src/internal/schema/toArbitrary.ts

@@ -717,7 +717,9 @@ function base(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): LazyArbitra
               : out.map(Option.some)
           }
         )
-        let out = fc.tuple(...elementArbitraries).map(Array.getSomes)
+        let out = fc.tuple(...elementArbitraries).map((elements) =>
+          Array.getSomes(Array.takeWhile(elements, Option.isSome))
+        )
         // ---------------------------------------------
         // handle rest element
         // ---------------------------------------------

package/src/internal/trie.ts

@@ -172,7 +172,7 @@ export const insert = dual<
     key: key[0],
     count: 0
   }
-  const count = n.count + 1
+  let count = n.count + 1
   let cIndex = 0
 
   while (cIndex < key.length) {
@@ -194,7 +194,17 @@ export const insert = dual<
       }
     } else {
       if (cIndex === key.length - 1) {
-        n.value = { value }
+        if (n.value !== undefined) {
+          count -= 1
+        }
+        nStack[nStack.length - 1] = {
+          key: n.key,
+          count,
+          value: { value },
+          left: n.left,
+          mid: n.mid,
+          right: n.right
+        }
       } else if (n.mid === undefined) {
         dStack.push(0)
         n = { key: key[cIndex + 1], count }

package/src/testing/TestClock.ts

@@ -203,6 +203,14 @@ const SleepOrder = Order.flip(Order.Struct({
   sequence: Order.Number
 }))
 
+const nanosPerMilli = BigInt(1_000_000)
+
+const millisToNanos = (millis: number): bigint => {
+  const wholeMillis = Math.floor(millis)
+  const fractionalNanos = Math.floor((millis - wholeMillis) * 1_000_000)
+  return BigInt(wholeMillis) * nanosPerMilli + BigInt(fractionalNanos)
+}
+
 /**
  * Creates a `TestClock` with optional configuration.
  *
@@ -247,6 +255,7 @@ export const make = Effect.fnUntraced(function*(
   const warningSemaphore = yield* Semaphore.make(1)
 
   let currentTimestamp: number = new Date(0).getTime()
+  let currentWallNanos = BigInt(0)
   let currentMonotonicNanos = BigInt(0)
   let warningState: WarningState = WarningState.Start()
 
@@ -255,7 +264,7 @@ export const make = Effect.fnUntraced(function*(
   }
 
   function currentTimeNanosUnsafe(): bigint {
-    return BigInt(Math.floor(currentTimestamp * 1000000))
+    return currentWallNanos
   }
 
   function monotonicTimeNanosUnsafe(): bigint {
@@ -339,6 +348,9 @@ export const make = Effect.fnUntraced(function*(
       if (deltaMillis > 0 && Number.isFinite(deltaMillis)) {
         currentMonotonicNanos += BigInt(Math.round(deltaMillis * 1_000_000))
       }
+      if (Number.isFinite(timestamp)) {
+        currentWallNanos = millisToNanos(timestamp)
+      }
       currentTimestamp = timestamp
     }
     while (Arr.isArrayNonEmpty(sleeps)) {

package/src/testing/TestSchema.ts

@@ -459,7 +459,7 @@ export class Encoding<S extends Schema.Constraint> {
   readonly encodeUnknownEffect: (
     input: unknown,
     options?: SchemaAST.ParseOptions
-  ) => Effect.Effect<S["Type"], SchemaIssue.Issue, S["EncodingServices"]>
+  ) => Effect.Effect<S["Encoded"], SchemaIssue.Issue, S["EncodingServices"]>
   readonly options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
   } | undefined