effect 4.0.5 → 4.0.7

package/src/Data.ts

@@ -392,13 +392,14 @@ export declare namespace TaggedEnum {
    * @category utility types
    * @since 3.1.0
    */
-  export type Constructor<A extends { readonly _tag: string }> = Types.Simplify<
-    {
+  export type Constructor<A extends { readonly _tag: string }> =
+    & {
       readonly [Tag in A["_tag"]]: ConstructorFrom<
         Extract<A, { readonly _tag: Tag }>,
         "_tag"
       >
-    } & {
+    }
+    & {
       readonly $is: <Tag extends A["_tag"]>(
         tag: Tag
       ) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
@@ -424,7 +425,6 @@ export declare namespace TaggedEnum {
         ): Unify<ReturnType<Cases[A["_tag"]]>>
       }
     }
-  >
 
   /**
    * Function type that constructs a tagged-union variant from its fields,
@@ -446,6 +446,61 @@ export declare namespace TaggedEnum {
     args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends Tag ? never : P]: A[P] }>
   ) => A
 
+  /**
+   * The full constructors-and-matchers object type returned by {@link taggedEnum}
+   * for a {@link WithGenerics} definition.
+   *
+   * **When to use**
+   *
+   * Use when you want to annotate an exported constructor bundle for a generic
+   * tagged enum.
+   *
+   * **Details**
+   *
+   * Includes one generic constructor per variant (keyed by tag name) plus the
+   * `$is` / `$match` helpers from {@link GenericMatchers}.
+   *
+   * @see {@link Constructor} — the non-generic equivalent
+   * @see {@link GenericCaseConstructor} — the constructor for one variant
+   *
+   * @category utility types
+   * @since 4.0.7
+   */
+  export type GenericConstructor<Z extends WithGenerics<1 | 2 | 3 | 4>> =
+    & {
+      readonly [Tag in Z["taggedEnum"]["_tag"]]: GenericCaseConstructor<Z, Tag>[Z["numberOfGenerics"]]
+    }
+    & GenericMatchers<Z>
+
+  /**
+   * The generic constructors for one variant of a {@link WithGenerics}
+   * definition, keyed by the number of generics.
+   *
+   * **When to use**
+   *
+   * Use to type an individual constructor for one variant of a generic tagged
+   * enum, by indexing with the definition's `numberOfGenerics`.
+   *
+   * @see {@link GenericConstructor} — the full constructor object type
+   *
+   * @category utility types
+   * @since 4.0.7
+   */
+  export interface GenericCaseConstructor<Z extends WithGenerics<number>, Tag extends Z["taggedEnum"]["_tag"]> {
+    readonly 1: <A>(
+      args: Args<Kind<Z, A>, Tag, Extract<Kind<Z, A>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A>, Tag>
+    readonly 2: <A, B>(
+      args: Args<Kind<Z, A, B>, Tag, Extract<Kind<Z, A, B>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B>, Tag>
+    readonly 3: <A, B, C>(
+      args: Args<Kind<Z, A, B, C>, Tag, Extract<Kind<Z, A, B, C>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B, C>, Tag>
+    readonly 4: <A, B, C, D>(
+      args: Args<Kind<Z, A, B, C, D>, Tag, Extract<Kind<Z, A, B, C, D>, { readonly _tag: Tag }>>
+    ) => Value<Kind<Z, A, B, C, D>, Tag>
+  }
+
   /**
    * Type-guard and pattern-matching interface for generic tagged enums.
    *
@@ -655,267 +710,7 @@ export const taggedEnum: {
    * @category constructors
    * @since 2.0.0
    */
-  <Z extends TaggedEnum.WithGenerics<1>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<2>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<3>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
-  /**
-   * Creates constructors and matchers for a `TaggedEnum` type.
-   *
-   * **When to use**
-   *
-   * Use when you model a closed union with plain data objects and want
-   * construction, tag checks, and exhaustive matching from the same definition.
-   *
-   * **Details**
-   *
-   * Returns an object with:
-   * - One constructor per variant (keyed by tag name)
-   * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field
-   * - `$match` — exhaustive pattern matching (data-first or data-last)
-   *
-   * **Gotchas**
-   *
-   * - Constructors produce **plain objects**, not class instances.
-   * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies
-   *   on the tag being globally unique and the value being produced by your
-   *   constructors. For untrusted input, validate with the `Schema` module first.
-   *
-   * **Example** (Creating and matching tagged enum values)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type HttpError = Data.TaggedEnum<{
-   *   BadRequest: { readonly message: string }
-   *   NotFound: { readonly url: string }
-   * }>
-   *
-   * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum<HttpError>()
-   *
-   * const err = NotFound({ url: "/missing" })
-   *
-   * $is("NotFound")(err) // => true
-   *
-   * $match(err, {
-   *   BadRequest: (e) => e.message,
-   *   NotFound: (e) => `${e.url} not found`
-   * }) // => "/missing not found"
-   * ```
-   *
-   * **Example** (Defining a generic tagged enum)
-   *
-   * ```ts import.meta.vitest
-   * import { Data } from "effect"
-   *
-   * type MyResult<E, A> = Data.TaggedEnum<{
-   *   Failure: { readonly error: E }
-   *   Success: { readonly value: A }
-   * }>
-   * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {
-   *   readonly taggedEnum: MyResult<this["A"], this["B"]>
-   * }
-   * const { Failure, Success } = Data.taggedEnum<MyResultDef>()
-   *
-   * const ok = Success({ value: 42 })
-   * // ok: { readonly _tag: "Success"; readonly value: number }
-   * ok // => { value: 42, _tag: "Success" }
-   * ```
-   *
-   * @see {@link TaggedEnum} — the type-level companion
-   * @see {@link TaggedEnum.Constructor} — the returned object type
-   * @see {@link TaggedEnum.WithGenerics} — generic enum support
-   *
-   * @stability stable
-   * @category constructors
-   * @since 2.0.0
-   */
-  <Z extends TaggedEnum.WithGenerics<4>>(): Types.Simplify<
-    {
-      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
-        args: TaggedEnum.Args<
-          TaggedEnum.Kind<Z, A, B, C, D>,
-          Tag,
-          Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
-        >
-      ) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, Tag>
-    } & TaggedEnum.GenericMatchers<Z>
-  >
-
+  <Z extends TaggedEnum.WithGenerics<1 | 2 | 3 | 4>>(): TaggedEnum.GenericConstructor<Z>
   /**
    * Creates constructors and matchers for a `TaggedEnum` type.
    *

package/src/Duration.ts

@@ -35,6 +35,10 @@ const bigint60 = BigInt(60)
 const bigint1e3 = BigInt(1_000)
 const bigint1e6 = BigInt(1_000_000)
 const bigint1e9 = BigInt(1_000_000_000)
+const bigintNanosPerMinute = BigInt(60_000_000_000)
+const bigintNanosPerHour = BigInt(3_600_000_000_000)
+const bigintNanosPerDay = BigInt(86_400_000_000_000)
+const bigintNanosPerWeek = BigInt(604_800_000_000_000)
 
 const roundTiesAwayFromZero = (input: number): bigint => BigInt(Math.sign(input) * Math.round(Math.abs(input)))
 
@@ -43,6 +47,14 @@ const roundMillisToNanos = (millis: number): bigint =>
 
 const fromNanosNumber = (nanos: number): Duration => make(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos)
 
+const nanosToUnit = (nanos: bigint, divisor: number): number => {
+  const value = Number(nanos)
+  // Preserve ordinary-input rounding; scale first only when nanoseconds overflow.
+  if (Number.isFinite(value)) return value / divisor
+  const scale = BigInt(divisor)
+  return Number(nanos / scale) + Number(nanos % scale) / divisor
+}
+
 const parseNanos = (input: string, scale: bigint): bigint => {
   const decimalIndex = input.indexOf(".")
   if (decimalIndex === -1) return BigInt(input) * scale
@@ -62,6 +74,14 @@ const divideTiesAwayFromZero = (numerator: bigint, denominator: bigint): bigint
   return numerator < bigint0 ? -rounded : rounded
 }
 
+const fromMillisString = (input: string, scale: number): Duration => {
+  const millis = Number(input) * scale
+  if (!Number.isFinite(millis)) return make(millis)
+  const nanos = parseNanos(input, BigInt(scale) * bigint1e6)
+  // Keep the millisecond representation only when it preserves the exact value.
+  return make(Number.isInteger(millis) && BigInt(millis) * bigint1e6 === nanos ? millis : nanos)
+}
+
 const nanosToHrTime = (nanos: bigint): [seconds: number, nanos: number] => {
   const sign = nanos < bigint0 ? -bigint1 : bigint1
   const absolute = nanos < bigint0 ? -nanos : nanos
@@ -274,26 +294,25 @@ export const fromInputUnsafe = (input: Input): Duration => {
       if (unit === "micro" || unit === "micros") {
         return nanos(parseNanos(valueStr, bigint1e3))
       }
-      const value = Number(valueStr)
       switch (unit) {
         case "milli":
         case "millis":
-          return millis(value)
+          return fromMillisString(valueStr, 1)
         case "second":
         case "seconds":
-          return seconds(value)
+          return fromMillisString(valueStr, 1_000)
         case "minute":
         case "minutes":
-          return minutes(value)
+          return fromMillisString(valueStr, 60_000)
         case "hour":
         case "hours":
-          return hours(value)
+          return fromMillisString(valueStr, 3_600_000)
         case "day":
         case "days":
-          return days(value)
+          return fromMillisString(valueStr, 86_400_000)
         case "week":
         case "weeks":
-          return weeks(value)
+          return fromMillisString(valueStr, 604_800_000)
       }
       break
     }
@@ -313,7 +332,10 @@ export const fromInputUnsafe = (input: Input): Duration => {
         if (input[0] === Infinity || input[1] === Infinity) {
           return infinity
         }
-        return fromNanosNumber(input[0] * 1_000_000_000 + input[1])
+        const nanos = input[0] * 1_000_000_000 + input[1]
+        return Number.isFinite(nanos) && Number.isInteger(input[0]) && Number.isInteger(input[1])
+          ? make(BigInt(input[0]) * bigint1e9 + BigInt(input[1]))
+          : fromNanosNumber(nanos)
       }
       const obj = input as DurationObject
       let millis = 0
@@ -324,13 +346,41 @@ export const fromInputUnsafe = (input: Input): Duration => {
       if (obj.minutes) millis += obj.minutes * 60_000
       if (obj.seconds) millis += obj.seconds * 1_000
       if (obj.milliseconds) millis += obj.milliseconds
-      if (!obj.microseconds && !obj.nanoseconds) return make(millis)
-      return fromNanosNumber(millis * 1_000_000 + (obj.microseconds ?? 0) * 1_000 + (obj.nanoseconds ?? 0))
+      if (!obj.microseconds && !obj.nanoseconds) {
+        if (!Number.isFinite(millis)) return make(millis)
+        const exact = sumObjectNanos(obj)
+        // keep the Millis representation when the numeric total is already exact
+        return exact === undefined || BigInt(millis) * bigint1e6 === exact ? make(millis) : make(exact)
+      }
+      const nanos = millis * 1_000_000 + (obj.microseconds ?? 0) * 1_000 + (obj.nanoseconds ?? 0)
+      const exact = Number.isFinite(nanos) ? sumObjectNanos(obj) : undefined
+      return exact === undefined ? fromNanosNumber(nanos) : make(exact)
     }
   }
   return invalid(input)
 }
 
+const isIntegerOrUnset = (n: number | undefined): boolean => !n || Number.isInteger(n)
+
+// sums the fields exactly, or returns undefined if any field is fractional
+const sumObjectNanos = (obj: DurationObject): bigint | undefined => {
+  if (
+    !isIntegerOrUnset(obj.weeks) || !isIntegerOrUnset(obj.days) || !isIntegerOrUnset(obj.hours) ||
+    !isIntegerOrUnset(obj.minutes) || !isIntegerOrUnset(obj.seconds) || !isIntegerOrUnset(obj.milliseconds) ||
+    !isIntegerOrUnset(obj.microseconds) || !isIntegerOrUnset(obj.nanoseconds)
+  ) return undefined
+  let nanos = bigint0
+  if (obj.weeks) nanos += BigInt(obj.weeks) * bigintNanosPerWeek
+  if (obj.days) nanos += BigInt(obj.days) * bigintNanosPerDay
+  if (obj.hours) nanos += BigInt(obj.hours) * bigintNanosPerHour
+  if (obj.minutes) nanos += BigInt(obj.minutes) * bigintNanosPerMinute
+  if (obj.seconds) nanos += BigInt(obj.seconds) * bigint1e9
+  if (obj.milliseconds) nanos += BigInt(obj.milliseconds) * bigint1e6
+  if (obj.microseconds) nanos += BigInt(obj.microseconds) * bigint1e3
+  if (obj.nanoseconds) nanos += BigInt(obj.nanoseconds)
+  return nanos
+}
+
 const invalid = (input: unknown): never => {
   throw new Error(`Invalid Input: ${input}`)
 }
@@ -817,7 +867,7 @@ export const weeks = (weeks: number): Duration => make(weeks * 604_800_000)
 export const toMillis = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: identity,
-    onNanos: (nanos) => Number(nanos) / 1_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 1_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -841,7 +891,7 @@ export const toMillis = (self: Input): number =>
 export const toSeconds = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 1_000,
-    onNanos: (nanos) => Number(nanos) / 1_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 1_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -865,7 +915,7 @@ export const toSeconds = (self: Input): number =>
 export const toMinutes = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 60_000,
-    onNanos: (nanos) => Number(nanos) / 60_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 60_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -889,7 +939,7 @@ export const toMinutes = (self: Input): number =>
 export const toHours = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 3_600_000,
-    onNanos: (nanos) => Number(nanos) / 3_600_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 3_600_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -913,7 +963,7 @@ export const toHours = (self: Input): number =>
 export const toDays = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 86_400_000,
-    onNanos: (nanos) => Number(nanos) / 86_400_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 86_400_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })
@@ -937,7 +987,7 @@ export const toDays = (self: Input): number =>
 export const toWeeks = (self: Input): number =>
   match(fromInputUnsafe(self), {
     onMillis: (millis) => millis / 604_800_000,
-    onNanos: (nanos) => Number(nanos) / 604_800_000_000_000,
+    onNanos: (nanos) => nanosToUnit(nanos, 604_800_000_000_000),
     onInfinity: () => Infinity,
     onNegativeInfinity: () => -Infinity
   })