effect 4.0.0-beta.5 → 4.0.0-beta.7

package/src/Channel.ts

@@ -69,6 +69,7 @@ import { constant, constTrue, constVoid, dual, identity as identity_ } from "./F
 import { ClockRef, endSpan } from "./internal/effect.ts"
 import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
+import * as Latch from "./Latch.ts"
 import * as Layer from "./Layer.ts"
 import type { LogLevel } from "./LogLevel.ts"
 import * as Option from "./Option.ts"
@@ -83,6 +84,7 @@ import { TracerTimingEnabled } from "./References.ts"
 import * as Result from "./Result.ts"
 import * as Schedule from "./Schedule.ts"
 import * as Scope from "./Scope.ts"
+import * as Semaphore from "./Semaphore.ts"
 import * as ServiceMap from "./ServiceMap.ts"
 import * as String from "./String.ts"
 import * as Take from "./Take.ts"
@@ -2084,7 +2086,7 @@ const mapEffectConcurrent = <
       const trackFiber = Fiber.runIn(forkedScope)
 
       if (options.unordered) {
-        const semaphore = Effect.makeSemaphoreUnsafe(concurrencyN)
+        const semaphore = Semaphore.makeUnsafe(concurrencyN)
         const release = constant(semaphore.release(1))
         const handle = Effect.matchCauseEffect({
           onFailure: (cause: Cause.Cause<EX>) => Effect.flatMap(Queue.failCause(queue, cause), release),
@@ -6631,8 +6633,8 @@ export const mergeAll: {
         const concurrencyN = concurrency === "unbounded"
           ? Number.MAX_SAFE_INTEGER
           : Math.max(1, concurrency)
-        const semaphore = switch_ ? undefined : Effect.makeSemaphoreUnsafe(concurrencyN)
-        const doneLatch = yield* Effect.makeLatch(true)
+        const semaphore = switch_ ? undefined : Semaphore.makeUnsafe(concurrencyN)
+        const doneLatch = yield* Latch.make(true)
         const fibers = new Set<Fiber.Fiber<any, any>>()
 
         const queue = yield* Queue.bounded</**
@@ -9085,7 +9087,7 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
   function*<OutElem, OutErr, OutDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
   ) {
-    const semaphore = Effect.makeSemaphoreUnsafe(1)
+    const semaphore = Semaphore.makeUnsafe(1)
     const context = yield* Effect.services<Env | Scope.Scope>()
     const scope = ServiceMap.get(context, Scope.Scope)
     const pull = yield* toTransform(self)(Cause.done(), scope)

package/src/Config.ts

@@ -938,7 +938,7 @@ export const Boolean = Schema.Literals([...TrueValues.literals, ...FalseValues.l
  * - Pass to {@link schema} for custom paths, or use the {@link duration}
  *   convenience constructor.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`).
  *
  * @see {@link duration} – convenience constructor
@@ -948,7 +948,7 @@ export const Boolean = Schema.Literals([...TrueValues.literals, ...FalseValues.l
  */
 export const Duration = Schema.String.pipe(Schema.decodeTo(Schema.Duration, {
   decode: Getter.transformOrFail((s) => {
-    const d = Duration_.fromDurationInput(s as any)
+    const d = Duration_.fromInput(s as any)
     return d ? Effect.succeed(d) : Effect.fail(new Issue.InvalidValue(Option.some(s)))
   }),
   encode: Getter.forbidden(() => "Encoding Duration is not supported")
@@ -1235,7 +1235,7 @@ export function boolean(name?: string) {
  *
  * Shortcut for `Config.schema(Config.Duration, name)`.
  *
- * Accepts any string that `Duration.fromDurationInput` can parse (e.g.
+ * Accepts any string that `Duration.fromInput` can parse (e.g.
  * `"10 seconds"`, `"500 millis"`, `"2 minutes"`).
  *
  * **Example** (Reading a duration)

package/src/Data.ts

@@ -13,6 +13,7 @@
  */
 import type * as Cause from "./Cause.ts"
 import * as core from "./internal/core.ts"
+import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Types from "./Types.ts"
 import type { Unify } from "./Unify.ts"
@@ -43,9 +44,12 @@ import type { Unify } from "./Unify.ts"
 export const Class: new<A extends Record<string, any> = {}>(
   args: Types.Equals<A, {}> extends true ? void
     : { readonly [P in keyof A]: A[P] }
-) => Readonly<A> = function(this: any, props: any) {
-  if (props) {
-    Object.assign(this, props)
+) => Readonly<A> & Pipeable.Pipeable = class extends Pipeable.Class {
+  constructor(props: any) {
+    super()
+    if (props) {
+      Object.assign(this, props)
+    }
   }
 } as any
 
@@ -79,12 +83,9 @@ export const TaggedClass = <Tag extends string>(
 ): 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] }
-) => Readonly<A> & { readonly _tag: Tag } =>
-  function(this: any, props: any) {
-    this._tag = tag
-    if (props) {
-      Object.assign(this, props)
-    }
+) => Readonly<A> & { readonly _tag: Tag } & Pipeable.Pipeable =>
+  class extends Class {
+    readonly _tag = tag
   } as any
 
 /**

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,