effect 4.0.0-beta.0 → 4.0.0-beta.10

package/src/DateTime.ts

@@ -12,7 +12,6 @@ import { provideService } from "./internal/effect.ts"
 import * as Layer from "./Layer.ts"
 import type * as order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
-import type * as Result from "./Result.ts"
 import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = Internal.TypeId
@@ -1174,10 +1173,12 @@ export const setZoneNamedUnsafe: {
 // =============================================================================
 
 /**
- * Calulate the difference between two `DateTime` values, returning the number
- * of milliseconds the `other` DateTime is from `self`.
+ * Calulate the difference between two `DateTime` values, returning a
+ * `Duration` representing the amount of time between them.
  *
- * If `other` is *after* `self`, the result will be a positive number.
+ * If `other` is *after* `self`, the result will be a positive `Duration`. If
+ * `other` is *before* `self`, the result will be a negative `Duration`. If they
+ * are equal, the result will be a `Duration` of zero.
  *
  * @since 3.6.0
  * @category comparisons
@@ -1189,7 +1190,7 @@ export const setZoneNamedUnsafe: {
  *   const now = yield* DateTime.now
  *   const other = DateTime.add(now, { minutes: 1 })
  *
- *   // returns 60000
+ *   // returns Duration.minutes(1)
  *   DateTime.distance(now, other)
  * })
  * ```
@@ -1200,10 +1201,12 @@ export const distance: {
   // =============================================================================
 
   /**
-   * Calulate the difference between two `DateTime` values, returning the number
-   * of milliseconds the `other` DateTime is from `self`.
+   * Calulate the difference between two `DateTime` values, returning a
+   * `Duration` representing the amount of time between them.
    *
-   * If `other` is *after* `self`, the result will be a positive number.
+   * If `other` is *after* `self`, the result will be a positive `Duration`. If
+   * `other` is *before* `self`, the result will be a negative `Duration`. If they
+   * are equal, the result will be a `Duration` of zero.
    *
    * @since 3.6.0
    * @category comparisons
@@ -1215,147 +1218,23 @@ export const distance: {
    *   const now = yield* DateTime.now
    *   const other = DateTime.add(now, { minutes: 1 })
    *
-   *   // returns 60000
+   *   // returns Duration.minutes(1)
    *   DateTime.distance(now, other)
    * })
    * ```
    */
-  (other: DateTime): (self: DateTime) => number
+  (other: DateTime): (self: DateTime) => Duration.Duration
   // =============================================================================
   // comparisons
   // =============================================================================
 
   /**
-   * Calulate the difference between two `DateTime` values, returning the number
-   * of milliseconds the `other` DateTime is from `self`.
-   *
-   * If `other` is *after* `self`, the result will be a positive number.
-   *
-   * @since 3.6.0
-   * @category comparisons
-   * @example
-   * ```ts
-   * import { DateTime, Effect } from "effect"
-   *
-   * Effect.gen(function*() {
-   *   const now = yield* DateTime.now
-   *   const other = DateTime.add(now, { minutes: 1 })
-   *
-   *   // returns 60000
-   *   DateTime.distance(now, other)
-   * })
-   * ```
-   */
-  (self: DateTime, other: DateTime): number
-} = Internal.distance
-
-/**
- * Calulate the difference between two `DateTime` values.
- *
- * If the `other` DateTime is before `self`, the result will be a negative
- * `Duration`, returned as a `Failure`.
- *
- * If the `other` DateTime is after `self`, the result will be a positive
- * `Duration`, returned as a `Success`.
- *
- * @since 3.6.0
- * @category comparisons
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
- *
- *   // returns Result.succeed(Duration.minutes(1))
- *   DateTime.distanceDurationResult(now, other)
- *
- *   // returns Result.fail(Duration.minutes(1))
- *   DateTime.distanceDurationResult(other, now)
- * })
- * ```
- */
-export const distanceDurationResult: {
-  /**
-   * Calulate the difference between two `DateTime` values.
-   *
-   * If the `other` DateTime is before `self`, the result will be a negative
-   * `Duration`, returned as a `Failure`.
+   * Calulate the difference between two `DateTime` values, returning a
+   * `Duration` representing the amount of time between them.
    *
-   * If the `other` DateTime is after `self`, the result will be a positive
-   * `Duration`, returned as a `Success`.
-   *
-   * @since 3.6.0
-   * @category comparisons
-   * @example
-   * ```ts
-   * import { DateTime, Effect } from "effect"
-   *
-   * Effect.gen(function*() {
-   *   const now = yield* DateTime.now
-   *   const other = DateTime.add(now, { minutes: 1 })
-   *
-   *   // returns Result.succeed(Duration.minutes(1))
-   *   DateTime.distanceDurationResult(now, other)
-   *
-   *   // returns Result.fail(Duration.minutes(1))
-   *   DateTime.distanceDurationResult(other, now)
-   * })
-   * ```
-   */
-  (other: DateTime): (self: DateTime) => Result.Result<Duration.Duration, Duration.Duration>
-  /**
-   * Calulate the difference between two `DateTime` values.
-   *
-   * If the `other` DateTime is before `self`, the result will be a negative
-   * `Duration`, returned as a `Failure`.
-   *
-   * If the `other` DateTime is after `self`, the result will be a positive
-   * `Duration`, returned as a `Success`.
-   *
-   * @since 3.6.0
-   * @category comparisons
-   * @example
-   * ```ts
-   * import { DateTime, Effect } from "effect"
-   *
-   * Effect.gen(function*() {
-   *   const now = yield* DateTime.now
-   *   const other = DateTime.add(now, { minutes: 1 })
-   *
-   *   // returns Result.succeed(Duration.minutes(1))
-   *   DateTime.distanceDurationResult(now, other)
-   *
-   *   // returns Result.fail(Duration.minutes(1))
-   *   DateTime.distanceDurationResult(other, now)
-   * })
-   * ```
-   */
-  (self: DateTime, other: DateTime): Result.Result<Duration.Duration, Duration.Duration>
-} = Internal.distanceDurationResult
-
-/**
- * Calulate the distance between two `DateTime` values.
- *
- * @since 3.6.0
- * @category comparisons
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function*() {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
- *
- *   // returns Duration.minutes(1)
- *   DateTime.distanceDuration(now, other)
- * })
- * ```
- */
-export const distanceDuration: {
-  /**
-   * Calulate the distance between two `DateTime` values.
+   * If `other` is *after* `self`, the result will be a positive `Duration`. If
+   * `other` is *before* `self`, the result will be a negative `Duration`. If they
+   * are equal, the result will be a `Duration` of zero.
    *
    * @since 3.6.0
    * @category comparisons
@@ -1368,31 +1247,12 @@ export const distanceDuration: {
    *   const other = DateTime.add(now, { minutes: 1 })
    *
    *   // returns Duration.minutes(1)
-   *   DateTime.distanceDuration(now, other)
-   * })
-   * ```
-   */
-  (other: DateTime): (self: DateTime) => Duration.Duration
-  /**
-   * Calulate the distance between two `DateTime` values.
-   *
-   * @since 3.6.0
-   * @category comparisons
-   * @example
-   * ```ts
-   * import { DateTime, Effect } from "effect"
-   *
-   * Effect.gen(function*() {
-   *   const now = yield* DateTime.now
-   *   const other = DateTime.add(now, { minutes: 1 })
-   *
-   *   // returns Duration.minutes(1)
-   *   DateTime.distanceDuration(now, other)
+   *   DateTime.distance(now, other)
    * })
    * ```
    */
   (self: DateTime, other: DateTime): Duration.Duration
-} = Internal.distanceDuration
+} = Internal.distance
 
 /**
  * Returns the earlier of two `DateTime` values.
@@ -3054,7 +2914,7 @@ export const addDuration: {
    * )
    * ```
    */
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
+  (duration: Duration.Input): <A extends DateTime>(self: A) => A
   // =============================================================================
   // math
   // =============================================================================
@@ -3074,7 +2934,7 @@ export const addDuration: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
+  <A extends DateTime>(self: A, duration: Duration.Input): A
 } = Internal.addDuration
 
 /**
@@ -3108,7 +2968,7 @@ export const subtractDuration: {
    * )
    * ```
    */
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
+  (duration: Duration.Input): <A extends DateTime>(self: A) => A
   /**
    * Subtract the given `Duration` from a `DateTime`.
    *
@@ -3124,7 +2984,7 @@ export const subtractDuration: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
+  <A extends DateTime>(self: A, duration: Duration.Input): A
 } = Internal.subtractDuration
 
 /**

package/src/Duration.ts

@@ -90,7 +90,7 @@ export type Unit =
  * @since 2.0.0
  * @category models
  */
-export type DurationInput =
+export type Input =
   | Duration
   | number // millis
   | bigint // nanos
@@ -100,23 +100,23 @@ export type DurationInput =
 const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/
 
 /**
- * Decodes a `DurationInput` into a `Duration`.
+ * Decodes a `Duration.Input` into a `Duration`.
  *
- * If the input is not a valid `DurationInput`, it throws an error.
+ * If the input is not a valid `Duration.Input`, it throws an error.
  *
  * @example
  * ```ts
  * import { Duration } from "effect"
  *
- * const duration1 = Duration.fromDurationInputUnsafe(1000) // 1000 milliseconds
- * const duration2 = Duration.fromDurationInputUnsafe("5 seconds")
- * const duration3 = Duration.fromDurationInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
+ * const duration1 = Duration.fromInputUnsafe(1000) // 1000 milliseconds
+ * const duration2 = Duration.fromInputUnsafe("5 seconds")
+ * const duration3 = Duration.fromInputUnsafe([2, 500_000_000]) // 2 seconds and 500ms
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
+export const fromInputUnsafe = (input: Input): Duration => {
   if (isDuration(input)) return input
   if (isNumber(input)) return millis(input)
   if (isBigInt(input)) return nanos(input)
@@ -168,11 +168,11 @@ export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
       }
     }
   }
-  throw new Error(`Invalid DurationInput: ${input}`)
+  throw new Error(`Invalid Input: ${input}`)
 }
 
 /**
- * Safely decodes a `DurationInput` value into a `Duration`, returning
+ * Safely decodes a `Input` value into a `Duration`, returning
  * `undefined` if decoding fails.
  *
  * **Example**
@@ -180,16 +180,16 @@ export const fromDurationInputUnsafe = (input: DurationInput): Duration => {
  * ```ts
  * import { Duration } from "effect"
  *
- * Duration.fromDurationInput(1000)?.pipe(Duration.toSeconds) // 1
+ * Duration.fromInput(1000)?.pipe(Duration.toSeconds) // 1
  *
- * Duration.fromDurationInput("invalid" as any) // undefined
+ * Duration.fromInput("invalid" as any) // undefined
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromDurationInput: (u: DurationInput) => Duration | undefined = UndefinedOr.liftThrowable(
-  fromDurationInputUnsafe
+export const fromInput: (u: Input) => Duration | undefined = UndefinedOr.liftThrowable(
+  fromInputUnsafe
 )
 
 const zeroDurationValue: DurationValue = { _tag: "Millis", millis: 0 }
@@ -611,8 +611,8 @@ export const weeks = (weeks: number): Duration => make(weeks * 604_800_000)
  * @since 2.0.0
  * @category getters
  */
-export const toMillis = (self: Duration): number =>
-  match(self, {
+export const toMillis = (self: Input): number =>
+  match(fromInputUnsafe(self), {
     onMillis: identity,
     onNanos: (nanos) => Number(nanos) / 1_000_000,
     onInfinity: () => Infinity,