effect 4.0.0 → 4.0.2

package/src/internal/arbitrary/array.ts

@@ -54,13 +54,13 @@ function rebuild<A>(
         }
         if (index >= elementStart) itemShrinks ??= children[index].shrinks?.()
         if (itemShrinks !== undefined) {
-          return Effect.matchEffect(itemShrinks, {
-            onFailure: () => {
+          return Effect.matchCauseEffect(itemShrinks, {
+            onFailure: Model.onTypedFailure(() => {
               itemShrinks = undefined
               removable = undefined
               index++
               return loop()
-            },
+            }),
             onSuccess: (item): Effect.Effect<Model.Attempt<Array<A>>> => {
               if (item._tag === "Discarded") return Effect.succeed(item)
               return Effect.succeed(rebuild(InternalArray.replaceAt(children, index, item), shape, index))

package/src/internal/arbitrary/model.ts

@@ -1,12 +1,32 @@
-import type * as Cause from "../../Cause.ts"
+import * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
 import * as Option from "../../Option.ts"
+import * as Result from "../../Result.ts"
 import * as InternalArray from "../array.ts"
 import { done } from "../core.ts"
 
 /** @internal */
 export type ShrinkPull<A> = Effect.Effect<A, Cause.Done>
 
+/**
+ * Builds a cause handler that recovers typed failures, or propagates only
+ * defects and interruptions, preserving their original annotations.
+ *
+ * @internal
+ */
+export const onTypedFailure = <E, A, E2, R>(
+  f: (error: E) => Effect.Effect<A, E2, R>
+) =>
+(cause: Cause.Cause<E>): Effect.Effect<A, E2, R> => {
+  if (!cause.reasons.every(Cause.isFailReason)) {
+    return Effect.failCause(Cause.fromReasons<never>(cause.reasons.filter(
+      (reason): reason is Cause.Die | Cause.Interrupt => reason._tag !== "Fail"
+    )))
+  }
+  const error = Cause.findError(cause)
+  return Result.isFailure(error) ? Effect.failCause(error.failure) : f(error.success)
+}
+
 /** @internal */
 export interface Sample<out A> {
   readonly _tag: "Generated"
@@ -129,10 +149,13 @@ export function concatPulls<A>(pulls: ReadonlyArray<ShrinkPull<A>>): ShrinkPull<
     Effect.suspend(() =>
       index >= pulls.length
         ? done()
-        : Effect.catch(pulls[index], () => {
-          index++
-          return loop()
-        })
+        : Effect.catchCause(
+          pulls[index],
+          onTypedFailure(() => {
+            index++
+            return loop()
+          })
+        )
     )
   return loop()
 }
@@ -182,11 +205,11 @@ export function retain<A>(sample: Sample<A>): Retained<A> {
       return Effect.suspend(() => {
         if (history !== undefined && index < history.length) return Effect.succeed(history[index++])
         if (ended) return done()
-        return Effect.matchEffect(source, {
-          onFailure: () => {
+        return Effect.matchCauseEffect(source, {
+          onFailure: onTypedFailure(() => {
             ended = true
             return done()
-          },
+          }),
           onSuccess: (attempt) => {
             const item = attempt._tag === "Discarded" ? attempt : retain(attempt)
             history ??= []
@@ -288,11 +311,11 @@ function filterMapPull<A, B>(
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (attempt) => {
           if (attempt._tag === "Discarded") return Effect.succeed<Attempt<B>>(attempt)
           const sample = attempt
@@ -318,11 +341,11 @@ function filterPull<A>(source: ShrinkPull<Attempt<A>>, predicate: (value: A) =>
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (attempt) => {
           if (attempt._tag === "Discarded") return Effect.succeed<Attempt<A>>(attempt)
           const sample = attempt

package/src/internal/arbitrary/runner.ts

@@ -383,11 +383,11 @@ function flatMapSourcePull<A, B>(
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: Model.onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (sourceAttempt) => {
           if (sourceAttempt._tag === "Discarded") return Effect.succeed<Model.Attempt<B>>(sourceAttempt)
           const sourceSample = sourceAttempt
@@ -505,14 +505,14 @@ const evaluateProperty = <A, E, R>(
 ): Effect.Effect<typeof passedProperty | PropertyFailure<E>, never, R> => {
   const output = property(value)
   if (!Effect.isEffect(output)) return Effect.succeed(output === true ? passedProperty : returnedFalse)
-  return Effect.matchEager(output, {
-    onFailure: (error): PropertyError<E> => ({ _tag: "PropertyError", error }),
-    onSuccess: (success) => success === true ? passedProperty : returnedFalse
+  return Effect.matchCauseEffectEager(output, {
+    onFailure: Model.onTypedFailure((error: E) => Effect.succeed<PropertyError<E>>({ _tag: "PropertyError", error })),
+    onSuccess: (success) => Effect.succeed(success === true ? passedProperty : returnedFalse)
   })
 }
 
 const pullNext = <A>(pull: Model.ShrinkPull<Model.Attempt<A>>): Effect.Effect<Model.Attempt<A> | undefined> =>
-  Effect.catch(pull, () => Effect.succeed(undefined))
+  Effect.catchCause(pull, Model.onTypedFailure(() => Effect.succeed(undefined)))
 
 const shrink = Effect.fnUntraced(function*<A, E, R>(
   initial: Model.Sample<A>,

package/src/internal/arbitrary/schema.ts

@@ -30,10 +30,11 @@ interface Checks {
 
 const infinity = Number.POSITIVE_INFINITY
 const finiteNumberConstraint: FilterConstraint = { number: "finite" }
-const optionMatch = { onFailure: Option.none, onSuccess: Option.some }
-
 const optionComputation = <A, E, R>(self: Effect.Effect<A, E, R>): Model.Computation<Option.Option<A>> => {
-  const result = Effect.matchEager(self, optionMatch) as Effect.Effect<Option.Option<A>>
+  const result = Effect.matchCauseEffectEager(self, {
+    onFailure: Model.onTypedFailure(() => Effect.succeedNone),
+    onSuccess: Effect.succeedSome
+  }) as Effect.Effect<Option.Option<A>>
   return effectIsExit(result) && result._tag === "Success" ? result.value : result
 }
 

package/src/internal/core.ts

@@ -279,6 +279,48 @@ export const causeFromReasons = <E>(
   reasons: ReadonlyArray<Cause.Reason<E>>
 ): Cause.Cause<E> => new CauseImpl(reasons)
 
+const dedupeReasons = <E>(
+  self: ReadonlyArray<Cause.Reason<E>>,
+  that: ReadonlyArray<Cause.Reason<E>>
+): Array<Cause.Reason<E>> => {
+  // Avoid importing Array.ts into the core bundle.
+  // Snapshot both arrays before invoking user-defined hash or equality methods.
+  const buckets = new Map<number, Array<Cause.Reason<E>>>()
+  const out: Array<Cause.Reason<E>> = []
+  for (const reason of self.concat(that)) {
+    const hash = Hash.hash(reason)
+    const bucket = buckets.get(hash)
+    if (bucket === undefined) {
+      buckets.set(hash, [reason])
+    } else if (bucket.some((previous) => Equal.equals(previous, reason))) {
+      continue
+    } else {
+      bucket.push(reason)
+    }
+    out.push(reason)
+  }
+  return out
+}
+
+/** @internal */
+export const causeCombine: {
+  <E2>(that: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E | E2>
+  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2>
+} = dual(
+  2,
+  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2> => {
+    if (self.reasons.length === 0) {
+      return that as Cause.Cause<E | E2>
+    } else if (that.reasons.length === 0) {
+      return self as Cause.Cause<E | E2>
+    }
+    const newCause = new CauseImpl<E | E2>(
+      dedupeReasons<E | E2>(self.reasons, that.reasons)
+    )
+    return Equal.equals(self, newCause) ? self : newCause
+  }
+)
+
 /** @internal */
 export const causeEmpty: Cause.Cause<never> = new CauseImpl([])
 
@@ -546,8 +588,20 @@ export const exitFailCause: <E>(cause: Cause.Cause<E>) => Exit.Exit<never, E> =
       annotated = true
     }
     let cont = fiber.getCont(contE)
-    while (fiber.interruptible && fiber._interruptedCause && cont) {
-      cont = fiber.getCont(contE)
+    const interruptedCause = fiber._interruptedCause
+    if (interruptedCause && fiber.interruptible) {
+      // Drop typed failures only when interruption skips a recovery handler.
+      // Interruptibility-restoration continuations have no identifier.
+      let skippedHandler = false
+      while (cont && fiber.interruptible) {
+        skippedHandler ||= identifier in cont
+        cont = fiber.getCont(contE)
+      }
+      if (skippedHandler) {
+        cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"))
+      }
+      cause = causeCombine(cause, interruptedCause)
+      annotated = true
     }
     return cont
       ? cont[contE](cause, fiber, annotated ? undefined : this)

package/src/internal/dateTime.ts

@@ -575,7 +575,9 @@ export const toDate = (self: DateTime.DateTime): Date => {
     Number(parts[3].value),
     Number(parts[4].value),
     Number(parts[5].value),
-    Number(parts[6].value)
+    parts[6]?.type === "fractionalSecond"
+      ? Number(parts[6].value)
+      : ((self.epochMilliseconds % 1000) + 1000) % 1000
   )
   self.adjustedEpochMilliseconds = date.getTime()
   return date