effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/internal/core.ts

@@ -70,7 +70,7 @@ export const PipeInspectableProto = {
     return { ...this }
   },
   toString() {
-    return format(this, { ignoreToString: true })
+    return format(this.toJSON(), { ignoreToString: true, space: 2 })
   },
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -102,6 +102,14 @@ export const YieldableProto = {
   }
 }
 
+/** @internal */
+export const YieldableErrorProto = {
+  ...YieldableProto,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
 /** @internal */
 export const EffectProto = {
   [EffectTypeId]: effectVariance,
@@ -581,13 +589,13 @@ export const YieldableError: new(
       return exitFail(this)
     }
   }
-  Object.assign(YieldableError.prototype, YieldableProto)
+  Object.assign(YieldableError.prototype, YieldableErrorProto)
   return YieldableError as any
 })()
 
 /** @internal */
 export const Error: new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A]: A[P] }>
 ) => Cause.YieldableError & Readonly<A> = (function() {
   const plainArgsSymbol = Symbol.for("effect/Data/Error/plainArgs")
   return class Base extends YieldableError {
@@ -611,8 +619,7 @@ export const Error: new<A extends Record<string, any> = {}>(
 export const TaggedError = <Tag extends string>(
   tag: Tag
 ): new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {
   class Base extends Error<{}> {
     readonly _tag = tag

package/src/internal/dateTime.ts

@@ -9,12 +9,11 @@ import type { LazyArg } from "../Function.ts"
 import { dual } from "../Function.ts"
 import * as Hash from "../Hash.ts"
 import * as Inspectable from "../Inspectable.ts"
+import * as Option from "../Option.ts"
 import * as order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import * as Predicate from "../Predicate.ts"
-import * as Result from "../Result.ts"
 import type { Mutable } from "../Types.ts"
-import * as UndefinedOr from "../UndefinedOr.ts"
 import * as effect from "./effect.ts"
 
 /** @internal */
@@ -40,10 +39,10 @@ const ProtoUtc = {
   ...Proto,
   _tag: "Utc",
   [Hash.symbol](this: DateTime.Utc) {
-    return Hash.number(this.epochMillis)
+    return Hash.number(this.epochMilliseconds)
   },
   [Equal.symbol](this: DateTime.Utc, that: unknown) {
-    return isDateTime(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis
+    return isDateTime(that) && that._tag === "Utc" && this.epochMilliseconds === that.epochMilliseconds
   },
   toString(this: DateTime.Utc) {
     return `DateTime.Utc(${toDateUtc(this).toJSON()})`
@@ -54,10 +53,10 @@ const ProtoZoned = {
   ...Proto,
   _tag: "Zoned",
   [Hash.symbol](this: DateTime.Zoned) {
-    return Hash.combine(Hash.number(this.epochMillis))(Hash.hash(this.zone))
+    return Hash.combine(Hash.number(this.epochMilliseconds))(Hash.hash(this.zone))
   },
   [Equal.symbol](this: DateTime.Zoned, that: unknown) {
-    return isDateTime(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis &&
+    return isDateTime(that) && that._tag === "Zoned" && this.epochMilliseconds === that.epochMilliseconds &&
       Equal.equals(this.zone, that.zone)
   },
   toString(this: DateTime.Zoned) {
@@ -121,7 +120,7 @@ export const makeZonedProto = (
   partsUtc?: DateTime.DateTime.PartsWithWeekday
 ): DateTime.Zoned => {
   const self = Object.create(ProtoZoned)
-  self.epochMillis = epochMillis
+  self.epochMilliseconds = epochMillis
   self.zone = zone
   Object.defineProperty(self, "partsUtc", {
     value: partsUtc,
@@ -170,11 +169,13 @@ export const isZoned = (self: DateTime.DateTime): self is DateTime.Zoned => self
 // =============================================================================
 
 /** @internal */
-export const Equivalence: Equ.Equivalence<DateTime.DateTime> = Equ.make((a, b) => a.epochMillis === b.epochMillis)
+export const Equivalence: Equ.Equivalence<DateTime.DateTime> = Equ.make((a, b) =>
+  a.epochMilliseconds === b.epochMilliseconds
+)
 
 /** @internal */
 export const Order: order.Order<DateTime.DateTime> = order.make((self, that) =>
-  self.epochMillis < that.epochMillis ? -1 : self.epochMillis > that.epochMillis ? 1 : 0
+  self.epochMilliseconds < that.epochMilliseconds ? -1 : self.epochMilliseconds > that.epochMilliseconds ? 1 : 0
 )
 
 /** @internal */
@@ -194,7 +195,7 @@ export const clamp: {
 
 const makeUtc = (epochMillis: number): DateTime.Utc => {
   const self = Object.create(ProtoUtc)
-  self.epochMillis = epochMillis
+  self.epochMilliseconds = epochMillis
   Object.defineProperty(self, "partsUtc", {
     value: undefined,
     enumerable: false,
@@ -219,6 +220,9 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
   } else if (input instanceof Date) {
     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>
+    }
     const date = new Date(0)
     setPartsDate(date, input)
     return fromDateUnsafe(date) as DateTime.DateTime.PreserveZone<A>
@@ -228,7 +232,14 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
   return fromDateUnsafe(new Date(input)) as DateTime.DateTime.PreserveZone<A>
 }
 
-const hasZone = (input: string): boolean => /Z|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input)
+/**
+ * Detects whether a date string already contains timezone info.
+ * Without a zone, `new Date("2024-01-01T12:00:00")` is parsed as local time,
+ * so `makeUnsafe` appends "Z" to force UTC interpretation.
+ * This check prevents appending "Z" to strings that already have a zone
+ * (e.g. "2024-01-01T12:00:00Z", "...+05:30", "...GMT"), which would produce invalid dates.
+ */
+const hasZone = (input: string): boolean => /Z|GMT|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input)
 
 const minEpochMillis = -8640000000000000 + (12 * 60 * 60 * 1000)
 const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)
@@ -239,32 +250,36 @@ export const makeZonedUnsafe = (input: DateTime.DateTime.Input, options?: {
   readonly adjustForTimeZone?: boolean | undefined
   readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned => {
-  if (options?.timeZone === undefined && isDateTime(input) && isZoned(input)) {
+  let timeZoneOption = options?.timeZone
+  if (timeZoneOption === undefined && isDateTime(input) && isZoned(input)) {
     return input
   }
   const self = makeUnsafe(input)
-  if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
-    throw new RangeError(`Epoch millis out of range: ${self.epochMillis}`)
+  if (self.epochMilliseconds < minEpochMillis || self.epochMilliseconds > maxEpochMillis) {
+    throw new RangeError(`Epoch millis out of range: ${self.epochMilliseconds}`)
+  }
+  if (timeZoneOption === undefined && typeof input === "object" && "timeZoneId" in input) {
+    timeZoneOption = input.timeZoneId
   }
   let zone: DateTime.TimeZone
-  if (options?.timeZone === undefined) {
-    const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
+  if (timeZoneOption === undefined) {
+    const offset = new Date(self.epochMilliseconds).getTimezoneOffset() * -60 * 1000
     zone = zoneMakeOffset(offset)
-  } else if (isTimeZone(options?.timeZone)) {
-    zone = options.timeZone
-  } else if (typeof options?.timeZone === "number") {
-    zone = zoneMakeOffset(options.timeZone)
+  } else if (isTimeZone(timeZoneOption)) {
+    zone = timeZoneOption
+  } else if (typeof timeZoneOption === "number") {
+    zone = zoneMakeOffset(timeZoneOption)
   } else {
-    const parsedZone = zoneFromString(options.timeZone)
-    if (parsedZone === undefined) {
-      throw new IllegalArgumentError(`Invalid time zone: ${options.timeZone}`)
+    const parsedZone = zoneFromString(timeZoneOption)
+    if (Option.isNone(parsedZone)) {
+      throw new IllegalArgumentError(`Invalid time zone: ${timeZoneOption}`)
     }
-    zone = parsedZone
+    zone = parsedZone.value
   }
   if (options?.adjustForTimeZone !== true) {
-    return makeZonedProto(self.epochMillis, zone, self.partsUtc)
+    return makeZonedProto(self.epochMilliseconds, zone, self.partsUtc)
   }
-  return makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
+  return makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? "compatible")
 }
 
 /** @internal */
@@ -275,20 +290,20 @@ export const makeZoned: (
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
   }
-) => DateTime.Zoned | undefined = UndefinedOr.liftThrowable(makeZonedUnsafe)
+) => Option.Option<DateTime.Zoned> = Option.liftThrowable(makeZonedUnsafe)
 
 /** @internal */
-export const make: <A extends DateTime.DateTime.Input>(input: A) => DateTime.DateTime.PreserveZone<A> | undefined =
-  UndefinedOr.liftThrowable(makeUnsafe)
+export const make: <A extends DateTime.DateTime.Input>(input: A) => Option.Option<DateTime.DateTime.PreserveZone<A>> =
+  Option.liftThrowable(makeUnsafe)
 
 const zonedStringRegExp = /^(.{17,35})\[(.+)\]$/
 
 /** @internal */
-export const makeZonedFromString = (input: string): DateTime.Zoned | undefined => {
+export const makeZonedFromString = (input: string): Option.Option<DateTime.Zoned> => {
   const match = zonedStringRegExp.exec(input)
   if (match === null) {
     const offset = parseOffset(input)
-    return offset !== null ? makeZoned(input, { timeZone: offset }) : undefined
+    return offset !== null ? makeZoned(input, { timeZone: offset }) : Option.none()
   }
   const [, isoString, timeZone] = match
   return makeZoned(isoString, { timeZone })
@@ -308,7 +323,7 @@ export const nowUnsafe: LazyArg<DateTime.Utc> = () => makeUtc(Date.now())
 // =============================================================================
 
 /** @internal */
-export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epochMillis)
+export const toUtc = (self: DateTime.DateTime): DateTime.Utc => makeUtc(self.epochMilliseconds)
 
 /** @internal */
 export const setZone: {
@@ -325,8 +340,8 @@ export const setZone: {
   readonly disambiguation?: DateTime.Disambiguation | undefined
 }): DateTime.Zoned =>
   options?.adjustForTimeZone === true
-    ? makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible")
-    : makeZonedProto(self.epochMillis, zone, self.partsUtc))
+    ? makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? "compatible")
+    : makeZonedProto(self.epochMilliseconds, zone, self.partsUtc))
 
 /** @internal */
 export const setZoneOffset: {
@@ -394,7 +409,7 @@ export const zoneMakeOffset = (offset: number): DateTime.TimeZone.Offset => {
 }
 
 /** @internal */
-export const zoneMakeNamed: (zoneId: string) => DateTime.TimeZone.Named | undefined = UndefinedOr.liftThrowable(
+export const zoneMakeNamed: (zoneId: string) => Option.Option<DateTime.TimeZone.Named> = Option.liftThrowable(
   zoneMakeNamedUnsafe
 )
 
@@ -412,10 +427,10 @@ export const zoneMakeLocal = (): DateTime.TimeZone.Named =>
 const offsetZoneRegExp = /^(?:GMT|[+-])/
 
 /** @internal */
-export const zoneFromString = (zone: string): DateTime.TimeZone | undefined => {
+export const zoneFromString = (zone: string): Option.Option<DateTime.TimeZone> => {
   if (offsetZoneRegExp.test(zone)) {
     const offset = parseOffset(zone)
-    return offset === null ? undefined : zoneMakeOffset(offset)
+    return offset === null ? Option.none() : Option.some(zoneMakeOffset(offset))
   }
   return zoneMakeNamed(zone)
 }
@@ -433,17 +448,17 @@ export const setZoneNamed: {
   (zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): (self: DateTime.DateTime) => DateTime.Zoned | undefined
+  }): (self: DateTime.DateTime) => Option.Option<DateTime.Zoned>
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): DateTime.Zoned | undefined
+  }): Option.Option<DateTime.Zoned>
 } = dual(
   isDateTimeArgs,
   (self: DateTime.DateTime, zoneId: string, options?: {
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: DateTime.Disambiguation | undefined
-  }): DateTime.Zoned | undefined => UndefinedOr.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
+  }): Option.Option<DateTime.Zoned> => Option.map(zoneMakeNamed(zoneId), (zone) => setZone(self, zone, options))
 )
 
 /** @internal */
@@ -467,32 +482,12 @@ export const setZoneNamedUnsafe: {
 
 /** @internal */
 export const distance: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => number
-  (self: DateTime.DateTime, other: DateTime.DateTime): number
-} = dual(2, (self: DateTime.DateTime, other: DateTime.DateTime): number => toEpochMillis(other) - toEpochMillis(self))
-
-/** @internal */
-export const distanceDurationResult: {
-  (other: DateTime.DateTime): (self: DateTime.DateTime) => Result.Result<Duration.Duration, Duration.Duration>
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration>
-} = dual(
-  2,
-  (self: DateTime.DateTime, other: DateTime.DateTime): Result.Result<Duration.Duration, Duration.Duration> => {
-    const diffMillis = distance(self, other)
-    return diffMillis > 0
-      ? Result.succeed(Duration.millis(diffMillis))
-      : Result.fail(Duration.millis(-diffMillis))
-  }
-)
-
-/** @internal */
-export const distanceDuration: {
   (other: DateTime.DateTime): (self: DateTime.DateTime) => Duration.Duration
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration
 } = dual(
   2,
   (self: DateTime.DateTime, other: DateTime.DateTime): Duration.Duration =>
-    Duration.millis(Math.abs(distance(self, other)))
+    Duration.millis(toEpochMillis(other) - toEpochMillis(self))
 )
 
 /** @internal */
@@ -554,18 +549,18 @@ export const isPastUnsafe = (self: DateTime.DateTime): boolean => isGreaterThan(
 // =============================================================================
 
 /** @internal */
-export const toDateUtc = (self: DateTime.DateTime): Date => new Date(self.epochMillis)
+export const toDateUtc = (self: DateTime.DateTime): Date => new Date(self.epochMilliseconds)
 
 /** @internal */
 export const toDate = (self: DateTime.DateTime): Date => {
   if (self._tag === "Utc") {
-    return new Date(self.epochMillis)
+    return new Date(self.epochMilliseconds)
   } else if (self.zone._tag === "Offset") {
-    return new Date(self.epochMillis + self.zone.offset)
-  } else if (self.adjustedEpochMillis !== undefined) {
-    return new Date(self.adjustedEpochMillis)
+    return new Date(self.epochMilliseconds + self.zone.offset)
+  } else if (self.adjustedEpochMilliseconds !== undefined) {
+    return new Date(self.adjustedEpochMilliseconds)
   }
-  const parts = self.zone.format.formatToParts(self.epochMillis).filter((_) => _.type !== "literal")
+  const parts = self.zone.format.formatToParts(self.epochMilliseconds).filter((_) => _.type !== "literal")
   const date = new Date(0)
   date.setUTCFullYear(
     Number(parts[2].value),
@@ -578,7 +573,7 @@ export const toDate = (self: DateTime.DateTime): Date => {
     Number(parts[5].value),
     Number(parts[6].value)
   )
-  self.adjustedEpochMillis = date.getTime()
+  self.adjustedEpochMilliseconds = date.getTime()
   return date
 }
 
@@ -603,7 +598,7 @@ const offsetToString = (offset: number): string => {
 export const zonedOffsetIso = (self: DateTime.Zoned): string => offsetToString(zonedOffset(self))
 
 /** @internal */
-export const toEpochMillis = (self: DateTime.DateTime): number => self.epochMillis
+export const toEpochMillis = (self: DateTime.DateTime): number => self.epochMilliseconds
 
 /** @internal */
 export const removeTime = (self: DateTime.DateTime): DateTime.Utc =>
@@ -617,10 +612,10 @@ export const removeTime = (self: DateTime.DateTime): DateTime.Utc =>
 // =============================================================================
 
 const dateToParts = (date: Date): DateTime.DateTime.PartsWithWeekday => ({
-  millis: date.getUTCMilliseconds(),
-  seconds: date.getUTCSeconds(),
-  minutes: date.getUTCMinutes(),
-  hours: date.getUTCHours(),
+  millisecond: date.getUTCMilliseconds(),
+  second: date.getUTCSeconds(),
+  minute: date.getUTCMinutes(),
+  hour: date.getUTCHours(),
   day: date.getUTCDate(),
   weekDay: date.getUTCDay(),
   month: date.getUTCMonth() + 1,
@@ -673,17 +668,17 @@ const setPartsDate = (date: Date, parts: Partial<DateTime.DateTime.PartsWithWeek
     const diff = parts.weekDay - date.getUTCDay()
     date.setUTCDate(date.getUTCDate() + diff)
   }
-  if (parts.hours !== undefined) {
-    date.setUTCHours(parts.hours)
+  if (parts.hour !== undefined) {
+    date.setUTCHours(parts.hour)
   }
-  if (parts.minutes !== undefined) {
-    date.setUTCMinutes(parts.minutes)
+  if (parts.minute !== undefined) {
+    date.setUTCMinutes(parts.minute)
   }
-  if (parts.seconds !== undefined) {
-    date.setUTCSeconds(parts.seconds)
+  if (parts.second !== undefined) {
+    date.setUTCSeconds(parts.second)
   }
-  if (parts.millis !== undefined) {
-    date.setUTCMilliseconds(parts.millis)
+  if (parts.millisecond !== undefined) {
+    date.setUTCMilliseconds(parts.millisecond)
   }
 }
 
@@ -911,22 +906,22 @@ export const match: {
 
 /** @internal */
 export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis + Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 /** @internal */
 export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime.DateTime>(self: A) => A
-  <A extends DateTime.DateTime>(self: A, duration: Duration.DurationInput): A
+  (duration: Duration.Input): <A extends DateTime.DateTime>(self: A) => A
+  <A extends DateTime.DateTime>(self: A, duration: Duration.Input): A
 } = dual(
   2,
-  (self: DateTime.DateTime, duration: Duration.DurationInput): DateTime.DateTime =>
-    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromDurationInputUnsafe(duration)))
+  (self: DateTime.DateTime, duration: Duration.Input): DateTime.DateTime =>
+    mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
 const addMillis = (date: Date, amount: number): void => {
@@ -946,8 +941,8 @@ export const add: {
   2,
   (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
     mutate(self, (date) => {
-      if (parts.millis) {
-        addMillis(date, parts.millis)
+      if (parts.milliseconds) {
+        addMillis(date, parts.milliseconds)
       }
       if (parts.seconds) {
         addMillis(date, parts.seconds * 1000)
@@ -1121,7 +1116,7 @@ export const nearest: {
   readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
 }): DateTime.DateTime =>
   mutate(self, (date) => {
-    if (part === "milli") return
+    if (part === "millisecond") return
     const millis = date.getTime()
     const start = new Date(millis)
     startOfDate(start, part, options)
@@ -1178,7 +1173,7 @@ export const format: {
     return new Intl.DateTimeFormat(options?.locale, {
       timeZone: self._tag === "Utc" ? "UTC" : intlTimeZone(self.zone),
       ...options
-    }).format(self.epochMillis)
+    }).format(self.epochMilliseconds)
   } catch {
     return new Intl.DateTimeFormat(options?.locale, {
       timeZone: "UTC",
@@ -1211,7 +1206,7 @@ export const formatLocal: {
       readonly locale?: Intl.LocalesArgument
     }
     | undefined
-): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMillis))
+): string => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMilliseconds))
 
 /** @internal */
 export const formatUtc: {
@@ -1241,13 +1236,13 @@ export const formatUtc: {
   new Intl.DateTimeFormat(options?.locale, {
     ...options,
     timeZone: "UTC"
-  }).format(self.epochMillis))
+  }).format(self.epochMilliseconds))
 
 /** @internal */
 export const formatIntl: {
   (format: Intl.DateTimeFormat): (self: DateTime.DateTime) => string
   (self: DateTime.DateTime, format: Intl.DateTimeFormat): string
-} = dual(2, (self: DateTime.DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMillis))
+} = dual(2, (self: DateTime.DateTime, format: Intl.DateTimeFormat): string => format.format(self.epochMilliseconds))
 
 /** @internal */
 export const formatIso = (self: DateTime.DateTime): string => toDateUtc(self).toISOString()