effect 3.12.7 → 3.12.8

package/src/Chunk.ts

@@ -242,9 +242,8 @@ export const empty: <A = never>() => Chunk<A> = () => _empty
  * @category constructors
  * @since 2.0.0
  */
-export const make = <As extends readonly [any, ...ReadonlyArray<any>]>(
-  ...as: As
-): NonEmptyChunk<As[number]> => as.length === 1 ? of(as[0]) : unsafeFromNonEmptyArray(as)
+export const make = <As extends readonly [any, ...ReadonlyArray<any>]>(...as: As): NonEmptyChunk<As[number]> =>
+  unsafeFromNonEmptyArray(as)
 
 /**
  * Builds a `NonEmptyChunk` from a single element.
@@ -261,7 +260,7 @@ export const of = <A>(a: A): NonEmptyChunk<A> => makeChunk({ _tag: "ISingleton",
  * @since 2.0.0
  */
 export const fromIterable = <A>(self: Iterable<A>): Chunk<A> =>
-  isChunk(self) ? self : makeChunk({ _tag: "IArray", array: RA.fromIterable(self) })
+  isChunk(self) ? self : unsafeFromArray(RA.fromIterable(self))
 
 const copyToArray = <A>(self: Chunk<A>, array: Array<any>, initial: number): void => {
   switch (self.backing._tag) {
@@ -408,7 +407,8 @@ export const get: {
  * @since 2.0.0
  * @category unsafe
  */
-export const unsafeFromArray = <A>(self: ReadonlyArray<A>): Chunk<A> => makeChunk({ _tag: "IArray", array: self })
+export const unsafeFromArray = <A>(self: ReadonlyArray<A>): Chunk<A> =>
+  self.length === 0 ? empty() : self.length === 1 ? of(self[0]) : makeChunk({ _tag: "IArray", array: self })
 
 /**
  * Wraps an array into a chunk without copying, unsafe on mutable arrays
@@ -1818,22 +1818,19 @@ export const zip: {
 )
 
 /**
- * Delete the element at the specified index, creating a new `Chunk`,
- * or returning the input if the index is out of bounds.
+ * Delete the element at the specified index, creating a new `Chunk`.
  *
  * @since 2.0.0
  */
 export const remove: {
   /**
-   * Delete the element at the specified index, creating a new `Chunk`,
-   * or returning the input if the index is out of bounds.
+   * Delete the element at the specified index, creating a new `Chunk`.
    *
    * @since 2.0.0
    */
   (i: number): <A>(self: Chunk<A>) => Chunk<A>
   /**
-   * Delete the element at the specified index, creating a new `Chunk`,
-   * or returning the input if the index is out of bounds.
+   * Delete the element at the specified index, creating a new `Chunk`.
    *
    * @since 2.0.0
    */

package/src/ConfigProvider.ts

@@ -195,6 +195,7 @@ export const fromFlat: (flat: ConfigProvider.Flat) => ConfigProvider = internal.
  */
 export const fromJson: (json: unknown) => ConfigProvider = internal.fromJson
 
+// TODO(4.0): use `_` for nested configs instead of `.` in next major
 /**
  * Constructs a ConfigProvider using a map and the specified delimiter string,
  * which determines how to split the keys in the map into path segments.

package/src/Cron.ts

@@ -7,7 +7,7 @@ import type * as DateTime from "./DateTime.js"
 import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as equivalence from "./Equivalence.js"
-import { constVoid, dual, pipe } from "./Function.js"
+import { constVoid, dual, identity, pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import { format, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
 import * as dateTime from "./internal/dateTime.js"
@@ -284,28 +284,45 @@ export const parse = (cron: string, tz?: DateTime.TimeZone | string): Either.Eit
 /**
  * Parses a cron expression into a `Cron` instance.
  *
- * Throws on failure.
+ * **Details**
  *
- * @param cron - The cron expression to parse.
+ * This function takes a cron expression as a string and attempts to parse it
+ * into a `Cron` instance. If the expression is valid, the resulting `Cron`
+ * instance will represent the schedule defined by the cron expression.
+ *
+ * If the expression is invalid, the function throws a `ParseError`.
+ *
+ * You can optionally provide a time zone (`tz`) to interpret the cron
+ * expression in a specific time zone. If no time zone is provided, the cron
+ * expression will use the default time zone.
  *
  * @example
  * ```ts
  * import { Cron } from "effect"
  *
  * // At 04:00 on every day-of-month from 8 through 14.
- * assert.deepStrictEqual(Cron.unsafeParse("0 4 8-14 * *"), Cron.make({
- *   minutes: [0],
- *   hours: [4],
- *   days: [8, 9, 10, 11, 12, 13, 14],
- *   months: [],
- *   weekdays: []
- * }))
+ * console.log(Cron.unsafeParse("0 4 8-14 * *"))
+ * // Output:
+ * // {
+ * //   _id: 'Cron',
+ * //   tz: { _id: 'Option', _tag: 'None' },
+ * //   seconds: [ 0 ],
+ * //   minutes: [ 0 ],
+ * //   hours: [ 4 ],
+ * //   days: [
+ * //      8,  9, 10, 11,
+ * //     12, 13, 14
+ * //   ],
+ * //   months: [],
+ * //   weekdays: []
+ * // }
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const unsafeParse = (cron: string, tz?: DateTime.TimeZone | string): Cron => Either.getOrThrow(parse(cron, tz))
+export const unsafeParse = (cron: string, tz?: DateTime.TimeZone | string): Cron =>
+  Either.getOrThrowWith(parse(cron, tz), identity)
 
 /**
  * Checks if a given `Date` falls within an active `Cron` time window.

package/src/Duration.ts

@@ -83,7 +83,7 @@ export type DurationInput =
   | Duration
   | number // millis
   | bigint // nanos
-  | [seconds: number, nanos: number]
+  | readonly [seconds: number, nanos: number]
   | `${number} ${Unit}`
 
 const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/
@@ -98,12 +98,17 @@ export const decode = (input: DurationInput): Duration => {
     return millis(input)
   } else if (isBigInt(input)) {
     return nanos(input)
-  } else if (Array.isArray(input)) {
-    if (input.length === 2 && isNumber(input[0]) && isNumber(input[1])) {
-      return nanos(BigInt(input[0]) * bigint1e9 + BigInt(input[1]))
+  } else if (Array.isArray(input) && input.length === 2 && input.every(isNumber)) {
+    if (input[0] === -Infinity || input[1] === -Infinity || Number.isNaN(input[0]) || Number.isNaN(input[1])) {
+      return zero
     }
+
+    if (input[0] === Infinity || input[1] === Infinity) {
+      return infinity
+    }
+
+    return nanos(BigInt(Math.round(input[0] * 1_000_000_000)) + BigInt(Math.round(input[1])))
   } else if (isString(input)) {
-    DURATION_REGEX.lastIndex = 0 // Reset the lastIndex before each use
     const match = DURATION_REGEX.exec(input)
     if (match) {
       const [_, valueStr, unit] = match

package/src/Effect.ts

@@ -21641,7 +21641,9 @@ export const schedule: {
    * @since 2.0.0
    * @category Repetition / Recursion
    */
-  <R2, Out>(schedule: Schedule.Schedule<Out, unknown, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
+  <A, R2, Out>(
+    schedule: Schedule.Schedule<Out, NoInfer<A> | undefined, R2>
+  ): <E, R>(self: Effect<A, E, R>) => Effect<Out, E, R2 | R>
   /**
    * Repeats an effect based on a specified schedule.
    *
@@ -21664,7 +21666,7 @@ export const schedule: {
    * @since 2.0.0
    * @category Repetition / Recursion
    */
-  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<Out, unknown, R2>): Effect<Out, E, R | R2>
+  <A, E, R, R2, Out>(self: Effect<A, E, R>, schedule: Schedule.Schedule<Out, A | undefined, R2>): Effect<Out, E, R | R2>
 } = schedule_.schedule_Effect
 
 /**
@@ -24422,6 +24424,7 @@ export interface Semaphore {
   /**
    * Acquires the specified number of permits and returns the resulting
    * available permits, suspending the task if they are not yet available.
+   * Concurrent pending `take` calls are processed in a first-in, first-out manner.
    */
   take(permits: number): Effect<number>
 

package/src/Either.ts

@@ -35,6 +35,7 @@ export const TypeId: unique symbol = either.TypeId
  */
 export type TypeId = typeof TypeId
 
+// TODO(4.0): flip the order of the type parameters
 /**
  * @category models
  * @since 2.0.0
@@ -52,6 +53,7 @@ export interface Left<out L, out R> extends Pipeable, Inspectable {
   [Unify.ignoreSymbol]?: EitherUnifyIgnore
 }
 
+// TODO(4.0): flip the order of the type parameters
 /**
  * @category models
  * @since 2.0.0
@@ -1054,6 +1056,7 @@ export const getOrThrowWith: {
   throw onLeft(self.left)
 })
 
+// TODO(4.0): by default should throw `L` (i.e getOrThrowWith with the identity function)
 /**
  * Extracts the value of an `Either` or throws if the `Either` is `Left`.
  *
@@ -1321,39 +1324,19 @@ const adapter = Gen.adapter<EitherTypeLambda>()
  * @since 2.0.0
  */
 export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (...args) => {
-  const f = (args.length === 1)
-    ? args[0]
-    : args[1].bind(args[0])
+  const f = args.length === 1 ? args[0] : args[1].bind(args[0])
   const iterator = f(adapter)
-  let state: IteratorYieldResult<any> | IteratorReturnResult<any> = iterator.next()
-  if (state.done) {
-    return right(state.value) as any
-  } else {
-    let current = state.value
-    if (Gen.isGenKind(current)) {
-      current = current.value
-    } else {
-      current = Gen.yieldWrapGet(current)
-    }
+  let state: IteratorResult<any> = iterator.next()
+  while (!state.done) {
+    const current = Gen.isGenKind(state.value)
+      ? state.value.value
+      : Gen.yieldWrapGet(state.value)
     if (isLeft(current)) {
       return current
     }
-    while (!state.done) {
-      state = iterator.next(current.right as never)
-      if (!state.done) {
-        current = state.value
-        if (Gen.isGenKind(current)) {
-          current = current.value
-        } else {
-          current = Gen.yieldWrapGet(current)
-        }
-        if (isLeft(current)) {
-          return current
-        }
-      }
-    }
-    return right(state.value)
+    state = iterator.next(current.right as never)
   }
+  return right(state.value) as any
 }
 
 // -------------------------------------------------------------------------------------

package/src/Layer.ts

@@ -888,7 +888,7 @@ export const retry: {
  * @since 2.0.0
  * @category constructors
  */
-export const scope: Layer<Scope.CloseableScope> = internal.scope
+export const scope: Layer<Scope.Scope> = internal.scope
 
 /**
  * Constructs a layer from the specified scoped effect.