effect 3.15.4 → 3.16.0

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.15.4";
+let moduleVersion = "3.16.0";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.15.4",
+  "version": "3.16.0",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {
@@ -187,6 +187,11 @@
       "import": "./dist/esm/Equivalence.js",
       "default": "./dist/cjs/Equivalence.js"
     },
+    "./ExecutionPlan": {
+      "types": "./dist/dts/ExecutionPlan.d.ts",
+      "import": "./dist/esm/ExecutionPlan.js",
+      "default": "./dist/cjs/ExecutionPlan.js"
+    },
     "./ExecutionStrategy": {
       "types": "./dist/dts/ExecutionStrategy.d.ts",
       "import": "./dist/esm/ExecutionStrategy.js",
@@ -991,6 +996,9 @@
       "Equivalence": [
         "./dist/dts/Equivalence.d.ts"
       ],
+      "ExecutionPlan": [
+        "./dist/dts/ExecutionPlan.d.ts"
+      ],
       "ExecutionStrategy": [
         "./dist/dts/ExecutionStrategy.d.ts"
       ],

package/src/Array.ts

@@ -2103,6 +2103,72 @@ export const findLast: {
   }
 )
 
+/**
+ * Counts all the element of the given array that pass the given predicate
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+ * console.log(result) // 2
+ * ```
+ *
+ * @category folding
+ * @since 3.16.0
+ */
+export const countBy: {
+  /**
+   * Counts all the element of the given array that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Array } from "effect"
+   *
+   * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+   * console.log(result) // 2
+   * ```
+   *
+   * @category folding
+   * @since 3.16.0
+   */
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => number
+  /**
+   * Counts all the element of the given array that pass the given predicate
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Array } from "effect"
+   *
+   * const result = Array.countBy([1, 2, 3, 4, 5], n => n % 2 === 0)
+   * console.log(result) // 2
+   * ```
+   *
+   * @category folding
+   * @since 3.16.0
+   */
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number
+} = dual(
+  2,
+  <A>(
+    self: Iterable<A>,
+    f: (a: A, i: number) => boolean
+  ): number => {
+    let count = 0
+    const as = fromIterable(self)
+    for (let i = 0; i < as.length; i++) {
+      const a = as[i]
+      if (f(a, i)) {
+        count++
+      }
+    }
+    return count
+  }
+)
+
 /**
  * Insert an element at the specified index, creating a new `NonEmptyArray`,
  * or return `None` if the index is out of bounds.
@@ -2315,8 +2381,15 @@ export const modify: {
   <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>
 } = dual(
   3,
-  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> =>
-    Option.getOrElse(modifyOption(self, i, f), () => Array.from(self))
+  <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> => {
+    const out: Array<A | B> = Array.from(self)
+    if (isOutOfBounds(i, out)) {
+      return out
+    }
+    const b = f(out[i] as A)
+    out[i] = b
+    return out
+  }
 )
 
 /**
@@ -2380,11 +2453,11 @@ export const modifyOption: {
    */
   <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option.Option<Array<A | B>> => {
-  const arr = Array.from(self)
+  const arr = fromIterable(self)
   if (isOutOfBounds(i, arr)) {
     return Option.none()
   }
-  const out: Array<A | B> = arr
+  const out: Array<A | B> = Array.isArray(self) ? self.slice() : arr
   const b = f(arr[i])
   out[i] = b
   return Option.some(out)
@@ -2459,6 +2532,76 @@ export const remove: {
   return out
 })
 
+/**
+ * Delete the element at the specified index, creating a new `Array`,
+ * or return `None` if the index is out of bounds.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { Array, Option } from "effect"
+ *
+ * const numbers = [1, 2, 3, 4]
+ * const result = Array.removeOption(numbers, 2)
+ * assert.deepStrictEqual(result, Option.some([1, 2, 4]))
+ *
+ * const outOfBoundsResult = Array.removeOption(numbers, 5)
+ * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
+ *
+ * @since 3.16.0
+ */
+export const removeOption: {
+  /**
+   * Delete the element at the specified index, creating a new `Array`,
+   * or return `None` if the index is out of bounds.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { Array, Option } from "effect"
+   *
+   * const numbers = [1, 2, 3, 4]
+   * const result = Array.removeOption(numbers, 2)
+   * assert.deepStrictEqual(result, Option.some([1, 2, 4]))
+   *
+   * const outOfBoundsResult = Array.removeOption(numbers, 5)
+   * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+   * ```
+   *
+   * @since 3.16.0
+   */
+  (i: number): <A>(self: Iterable<A>) => Option.Option<Array<A>>
+  /**
+   * Delete the element at the specified index, creating a new `Array`,
+   * or return `None` if the index is out of bounds.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { Array, Option } from "effect"
+   *
+   * const numbers = [1, 2, 3, 4]
+   * const result = Array.removeOption(numbers, 2)
+   * assert.deepStrictEqual(result, Option.some([1, 2, 4]))
+   *
+   * const outOfBoundsResult = Array.removeOption(numbers, 5)
+   * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+   * ```
+   *
+   * @since 3.16.0
+   */
+  <A>(self: Iterable<A>, i: number): Option.Option<Array<A>>
+} = dual(2, <A>(self: Iterable<A>, i: number): Option.Option<Array<A>> => {
+  const arr = fromIterable(self)
+  if (isOutOfBounds(i, arr)) {
+    return Option.none()
+  }
+  const out = Array.isArray(self) ? self.slice() : arr
+  out.splice(i, 1)
+  return Option.some(out)
+})
+
 /**
  * Reverse an `Iterable`, creating a new `Array`.
  *

package/src/BigDecimal.ts

@@ -1680,3 +1680,358 @@ export const isNegative = (n: BigDecimal): boolean => n.value < bigint0
  * @category predicates
  */
 export const isPositive = (n: BigDecimal): boolean => n.value > bigint0
+
+const isBigDecimalArgs = (args: IArguments) => isBigDecimal(args[0])
+
+/**
+ * Calculate the ceiling of a `BigDecimal` at the given scale.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { ceil, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150"))
+ * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+export const ceil: {
+  /**
+   * Calculate the ceiling of a `BigDecimal` at the given scale.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { ceil, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150"))
+   * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (scale: number): (self: BigDecimal) => BigDecimal
+  /**
+   * Calculate the ceiling of a `BigDecimal` at the given scale.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { ceil, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(ceil(unsafeFromString("145"), -1), unsafeFromString("150"))
+   * assert.deepStrictEqual(ceil(unsafeFromString("-14.5")), unsafeFromString("-14"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (self: BigDecimal, scale?: number): BigDecimal
+} = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {
+  const truncated = truncate(self, scale)
+
+  if (isPositive(self) && lessThan(truncated, self)) {
+    return sum(truncated, make(1n, scale))
+  }
+
+  return truncated
+})
+
+/**
+ * Calculate the floor of a `BigDecimal` at the given scale.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { floor, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140"))
+ * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+export const floor: {
+  /**
+   * Calculate the floor of a `BigDecimal` at the given scale.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { floor, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140"))
+   * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (scale: number): (self: BigDecimal) => BigDecimal
+  /**
+   * Calculate the floor of a `BigDecimal` at the given scale.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { floor, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(floor(unsafeFromString("145"), -1), unsafeFromString("140"))
+   * assert.deepStrictEqual(floor(unsafeFromString("-14.5")), unsafeFromString("-15"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (self: BigDecimal, scale?: number): BigDecimal
+} = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {
+  const truncated = truncate(self, scale)
+
+  if (isNegative(self) && greaterThan(truncated, self)) {
+    return sum(truncated, make(-1n, scale))
+  }
+
+  return truncated
+})
+
+/**
+ * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { truncate, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140"))
+ * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+export const truncate: {
+  /**
+   * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { truncate, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140"))
+   * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (scale: number): (self: BigDecimal) => BigDecimal
+  /**
+   * Truncate a `BigDecimal` at the given scale. This is the same operation as rounding away from zero.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { truncate, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(truncate(unsafeFromString("145"), -1), unsafeFromString("140"))
+   * assert.deepStrictEqual(truncate(unsafeFromString("-14.5")), unsafeFromString("-14"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (self: BigDecimal, scale?: number): BigDecimal
+} = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {
+  if (self.scale <= scale) {
+    return self
+  }
+
+  // BigInt division truncates towards zero
+  return make(self.value / (10n ** BigInt(self.scale - scale)), scale)
+})
+
+/**
+ * Internal function used by `round` for `half-even` and `half-odd` rounding modes.
+ *
+ * Returns the digit at the position of the given `scale` within the `BigDecimal`.
+ *
+ * @internal
+ */
+export const digitAt: {
+  /**
+   * Internal function used by `round` for `half-even` and `half-odd` rounding modes.
+   *
+   * Returns the digit at the position of the given `scale` within the `BigDecimal`.
+   *
+   * @internal
+   */
+  (scale: number): (self: BigDecimal) => bigint
+  /**
+   * Internal function used by `round` for `half-even` and `half-odd` rounding modes.
+   *
+   * Returns the digit at the position of the given `scale` within the `BigDecimal`.
+   *
+   * @internal
+   */
+  (self: BigDecimal, scale: number): bigint
+} = dual(2, (self: BigDecimal, scale: number): bigint => {
+  if (self.scale < scale) {
+    return 0n
+  }
+
+  const scaled = self.value / (10n ** BigInt(self.scale - scale))
+  return scaled % 10n
+})
+
+/**
+ * Rounding modes for `BigDecimal`.
+ *
+ * `ceil`: round towards positive infinity
+ * `floor`: round towards negative infinity
+ * `to-zero`: round towards zero
+ * `from-zero`: round away from zero
+ * `half-ceil`: round to the nearest neighbor; if equidistant round towards positive infinity
+ * `half-floor`: round to the nearest neighbor; if equidistant round towards negative infinity
+ * `half-to-zero`: round to the nearest neighbor; if equidistant round towards zero
+ * `half-from-zero`: round to the nearest neighbor; if equidistant round away from zero
+ * `half-even`: round to the nearest neighbor; if equidistant round to the neighbor with an even digit
+ * `half-odd`: round to the nearest neighbor; if equidistant round to the neighbor with an odd digit
+ *
+ * @since 3.16.0
+ * @category math
+ */
+export type RoundingMode =
+  | "ceil"
+  | "floor"
+  | "to-zero"
+  | "from-zero"
+  | "half-ceil"
+  | "half-floor"
+  | "half-to-zero"
+  | "half-from-zero"
+  | "half-even"
+  | "half-odd"
+
+/**
+ * Rounds a `BigDecimal` at the given scale with the specified rounding mode.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { round, unsafeFromString } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150"))
+ * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15"))
+ * ```
+ *
+ * @since 3.16.0
+ * @category math
+ */
+export const round: {
+  /**
+   * Rounds a `BigDecimal` at the given scale with the specified rounding mode.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { round, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150"))
+   * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (options: { scale?: number; mode?: RoundingMode }): (self: BigDecimal) => BigDecimal
+  /**
+   * Rounds a `BigDecimal` at the given scale with the specified rounding mode.
+   *
+   * @example
+   * ```ts
+   * import * as assert from "node:assert"
+   * import { round, unsafeFromString } from "effect/BigDecimal"
+   *
+   * assert.deepStrictEqual(round(unsafeFromString("145"), { mode: "from-zero", scale: -1 }), unsafeFromString("150"))
+   * assert.deepStrictEqual(round(unsafeFromString("-14.5")), unsafeFromString("-15"))
+   * ```
+   *
+   * @since 3.16.0
+   * @category math
+   */
+  (n: BigDecimal, options?: { scale?: number; mode?: RoundingMode }): BigDecimal
+} = dual(isBigDecimalArgs, (self: BigDecimal, options?: { scale?: number; mode?: RoundingMode }): BigDecimal => {
+  const mode = options?.mode ?? "half-from-zero"
+  const scale = options?.scale ?? 0
+
+  switch (mode) {
+    case "ceil":
+      return ceil(self, scale)
+
+    case "floor":
+      return floor(self, scale)
+
+    case "to-zero":
+      return truncate(self, scale)
+
+    case "from-zero":
+      return (isPositive(self) ? ceil(self, scale) : floor(self, scale))
+
+    case "half-ceil":
+      return floor(sum(self, make(5n, scale + 1)), scale)
+
+    case "half-floor":
+      return ceil(sum(self, make(-5n, scale + 1)), scale)
+
+    case "half-to-zero":
+      return isNegative(self)
+        ? floor(sum(self, make(5n, scale + 1)), scale)
+        : ceil(sum(self, make(-5n, scale + 1)), scale)
+
+    case "half-from-zero":
+      return isNegative(self)
+        ? ceil(sum(self, make(-5n, scale + 1)), scale)
+        : floor(sum(self, make(5n, scale + 1)), scale)
+  }
+
+  const halfCeil = floor(sum(self, make(5n, scale + 1)), scale)
+  const halfFloor = ceil(sum(self, make(-5n, scale + 1)), scale)
+  const digit = digitAt(halfCeil, scale)
+
+  switch (mode) {
+    case "half-even":
+      return equals(halfCeil, halfFloor) ? halfCeil : (digit % 2n === 0n) ? halfCeil : halfFloor
+
+    case "half-odd":
+      return equals(halfCeil, halfFloor) ? halfCeil : (digit % 2n === 0n) ? halfFloor : halfCeil
+  }
+})
+
+/**
+ * Takes an `Iterable` of `BigDecimal`s and returns their sum as a single `BigDecimal`
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { unsafeFromString, sumAll } from "effect/BigDecimal"
+ *
+ * assert.deepStrictEqual(sumAll([unsafeFromString("2"), unsafeFromString("3"), unsafeFromString("4")]), unsafeFromString("9"))
+ * ```
+ *
+ * @category math
+ * @since 3.16.0
+ */
+export const sumAll = (collection: Iterable<BigDecimal>): BigDecimal => {
+  let out = zero
+  for (const n of collection) {
+    out = sum(out, n)
+  }
+
+  return out
+}

package/src/Chunk.ts

@@ -1863,7 +1863,30 @@ export const remove: {
   <A>(self: Chunk<A>, i: number): Chunk<A>
 } = dual(
   2,
-  <A>(self: Chunk<A>, i: number): Chunk<A> => unsafeFromArray(RA.remove(toReadonlyArray(self), i))
+  <A>(self: Chunk<A>, i: number): Chunk<A> => {
+    if (i < 0 || i >= self.length) return self
+    return unsafeFromArray(RA.remove(toReadonlyArray(self), i))
+  }
+)
+
+/**
+ * @since 3.16.0
+ */
+export const removeOption: {
+  /**
+   * @since 3.16.0
+   */
+  (i: number): <A>(self: Chunk<A>) => Option<Chunk<A>>
+  /**
+   * @since 3.16.0
+   */
+  <A>(self: Chunk<A>, i: number): Option<Chunk<A>>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, i: number): Option<Chunk<A>> => {
+    if (i < 0 || i >= self.length) return O.none()
+    return O.some(unsafeFromArray(RA.remove(toReadonlyArray(self), i)))
+  }
 )
 
 /**
@@ -1880,8 +1903,10 @@ export const modifyOption: {
   <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>
 } = dual(
   3,
-  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>> =>
-    O.map(RA.modifyOption(toReadonlyArray(self), i, f), unsafeFromArray)
+  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>> => {
+    if (i < 0 || i >= self.length) return O.none()
+    return O.some(unsafeFromArray(RA.modify(toReadonlyArray(self), i, f)))
+  }
 )
 
 /**

package/src/Config.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import type * as Brand from "./Brand.js"
 import type * as Chunk from "./Chunk.js"
 import type * as ConfigError from "./ConfigError.js"
 import type * as Duration from "./Duration.js"
@@ -129,7 +130,15 @@ export const array: <A>(config: Config<A>, name?: string) => Config<Array<A>> =
 export const boolean: (name?: string) => Config<boolean> = internal.boolean
 
 /**
- * Constructs a config for a URL value.
+ * Constructs a config for a network port [1, 65535].
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+export const port: (name?: string) => Config<number> = internal.port
+
+/**
+ * Constructs a config for an URL value.
  *
  * @since 3.11.0
  * @category constructors
@@ -464,6 +473,36 @@ export const redacted: {
   <A>(config: Config<A>): Config<Redacted.Redacted<A>>
 } = internal.redacted
 
+/**
+ * Constructs a config for a branded value.
+ *
+ * @since 3.16.0
+ * @category constructors
+ */
+export const branded: {
+  /**
+   * Constructs a config for a branded value.
+   *
+   * @since 3.16.0
+   * @category constructors
+   */
+  <A, B extends Brand.Branded<A, any>>(constructor: Brand.Brand.Constructor<B>): (config: Config<A>) => Config<B>
+  /**
+   * Constructs a config for a branded value.
+   *
+   * @since 3.16.0
+   * @category constructors
+   */
+  <B extends Brand.Branded<string, any>>(name: string | undefined, constructor: Brand.Brand.Constructor<B>): Config<B>
+  /**
+   * Constructs a config for a branded value.
+   *
+   * @since 3.16.0
+   * @category constructors
+   */
+  <A, B extends Brand.Branded<A, any>>(config: Config<A>, constructor: Brand.Brand.Constructor<B>): Config<B>
+} = internal.branded
+
 /**
  * Constructs a config for a sequence of values.
  *