effect 3.14.21 → 3.15.0

package/src/Either.ts

@@ -1614,3 +1614,110 @@ export const transposeOption = <A = never, E = never>(
 ): Either<Option<A>, E> => {
   return option_.isNone(self) ? right(option_.none) : map(self.value, option_.some)
 }
+
+/**
+ * Applies an `Either` on an `Option` and transposes the result.
+ *
+ * **Details**
+ *
+ * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+ * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+ *
+ * @example
+ * ```ts
+ * import { Either, Option, pipe } from "effect"
+ *
+ * //          ┌─── Either<Option<number>, never>>
+ * //          ▼
+ * const noneResult = pipe(
+ *   Option.none(),
+ *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+ * )
+ * console.log(noneResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+ *
+ * //          ┌─── Either<Option<number>, never>>
+ * //          ▼
+ * const someRightResult = pipe(
+ *   Option.some(42),
+ *   Either.transposeMapOption((value) => Either.right(value * 2))
+ * )
+ * console.log(someRightResult)
+ * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+ * ```
+ *
+ * @since 3.15.0
+ * @category Optional Wrapping & Unwrapping
+ */
+export const transposeMapOption = dual<
+  /**
+   * Applies an `Either` on an `Option` and transposes the result.
+   *
+   * **Details**
+   *
+   * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+   * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+   *
+   * @example
+   * ```ts
+   * import { Either, Option, pipe } from "effect"
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const noneResult = pipe(
+   *   Option.none(),
+   *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+   * )
+   * console.log(noneResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const someRightResult = pipe(
+   *   Option.some(42),
+   *   Either.transposeMapOption((value) => Either.right(value * 2))
+   * )
+   * console.log(someRightResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+   * ```
+   *
+   * @since 3.15.0
+   * @category Optional Wrapping & Unwrapping
+   */
+  <A, B, E = never>(f: (self: A) => Either<B, E>) => (self: Option<A>) => Either<Option<B>, E>,
+  /**
+   * Applies an `Either` on an `Option` and transposes the result.
+   *
+   * **Details**
+   *
+   * If the `Option` is `None`, the resulting `Either` will immediately succeed with a `Right` value of `None`.
+   * If the `Option` is `Some`, the transformation function will be applied to the inner value, and its result wrapped in a `Some`.
+   *
+   * @example
+   * ```ts
+   * import { Either, Option, pipe } from "effect"
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const noneResult = pipe(
+   *   Option.none(),
+   *   Either.transposeMapOption(() => Either.right(42)) // will not be executed
+   * )
+   * console.log(noneResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'None' } }
+   *
+   * //          ┌─── Either<Option<number>, never>>
+   * //          ▼
+   * const someRightResult = pipe(
+   *   Option.some(42),
+   *   Either.transposeMapOption((value) => Either.right(value * 2))
+   * )
+   * console.log(someRightResult)
+   * // Output: { _id: 'Either', _tag: 'Right', right: { _id: 'Option', _tag: 'Some', value: 84 } }
+   * ```
+   *
+   * @since 3.15.0
+   * @category Optional Wrapping & Unwrapping
+   */
+  <A, B, E = never>(self: Option<A>, f: (self: A) => Either<B, E>) => Either<Option<B>, E>
+>(2, (self, f) => option_.isNone(self) ? right(option_.none) : map(f(self.value), option_.some))

package/src/Function.ts

@@ -293,7 +293,7 @@ export const dual: {
   }
 }
 /**
- * Apply a function to a given value.
+ * Apply a function to given values.
  *
  * @example
  * ```ts
@@ -306,7 +306,7 @@ export const dual: {
  *
  * @since 2.0.0
  */
-export const apply = <A>(a: A) => <B>(self: (a: A) => B): B => self(a)
+export const apply = <A extends ReadonlyArray<unknown>>(...a: A) => <B>(self: (...a: A) => B): B => self(...a)
 
 /**
  * A lazy argument.

package/src/Layer.ts

@@ -32,9 +32,11 @@ import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as internal from "./internal/layer.js"
 import * as circularLayer from "./internal/layer/circular.js"
 import * as query from "./internal/query.js"
+import { randomTag } from "./internal/random.js"
 import type { LogLevel } from "./LogLevel.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Random from "./Random.js"
 import type * as Request from "./Request.js"
 import type * as Runtime from "./Runtime.js"
 import type * as Schedule from "./Schedule.js"
@@ -1280,6 +1282,15 @@ export const setConfigProvider: (configProvider: ConfigProvider) => Layer<never>
  */
 export const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSpan> = circularLayer.parentSpan
 
+/**
+ * @since 3.15.0
+ * @category Random
+ */
+export const setRandom = <A extends Random.Random>(random: A): Layer<never> =>
+  scopedDiscard(
+    fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, random))
+  )
+
 /**
  * @since 2.0.0
  * @category requests & batching

package/src/MutableHashMap.ts

@@ -102,7 +102,7 @@ class BucketIterator<K, V> implements Iterator<[K, V]> {
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <K, V>(): MutableHashMap<K, V> => {
+export const empty = <K = never, V = never>(): MutableHashMap<K, V> => {
   const self = Object.create(MutableHashMapProto)
   self.referential = new Map()
   self.buckets = new Map()

package/src/MutableList.ts

@@ -97,7 +97,7 @@ const makeNode = <T>(value: T): LinkedListNode<T> => ({
  * @since 2.0.0
  * @category constructors
  */
-export const empty = <A>(): MutableList<A> => {
+export const empty = <A = never>(): MutableList<A> => {
   const list = Object.create(MutableListProto)
   list.head = undefined
   list.tail = undefined

package/src/Pipeable.ts

@@ -2,9 +2,11 @@
  * @since 2.0.0
  */
 
+import type { Ctor } from "./Types.js"
+
 /**
  * @since 2.0.0
- * @category models
+ * @category Models
  */
 export interface Pipeable {
   pipe<A>(this: A): A
@@ -522,3 +524,51 @@ export const pipeArguments = <A>(self: A, args: IArguments): unknown => {
     }
   }
 }
+
+/**
+ * @since 3.15.0
+ * @category Models
+ */
+export interface PipeableConstructor {
+  new(...args: Array<any>): Pipeable
+}
+
+/**
+ * @since 3.15.0
+ * @category Prototypes
+ */
+export const Prototype: Pipeable = {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const Base: PipeableConstructor = (function() {
+  function PipeableBase() {}
+  PipeableBase.prototype = Prototype
+  return PipeableBase as any
+})()
+
+/**
+ * @since 3.15.0
+ * @category Constructors
+ */
+export const Class: {
+  /**
+   * @since 3.15.0
+   * @category Constructors
+   */
+  (): PipeableConstructor
+  /**
+   * @since 3.15.0
+   * @category Constructors
+   */
+  <TBase extends Ctor>(klass: TBase): TBase & PipeableConstructor
+} = (klass?: Ctor) =>
+  klass ?
+    class extends klass {
+      pipe() {
+        return pipeArguments(this, arguments)
+      }
+    }
+    : Base

package/src/Record.ts

@@ -1883,3 +1883,123 @@ export const getEquivalence = <K extends string, A>(
 export const singleton = <K extends string | symbol, A>(key: K, value: A): Record<K, A> => ({
   [key]: value
 } as any)
+
+/**
+ * Returns the first entry that satisfies the specified
+ * predicate, or `None` if no such entry exists.
+ *
+ * @example
+ * ```ts
+ * import { Record, Option } from "effect"
+ *
+ * const record = { a: 1, b: 2, c: 3 }
+ * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+ * console.log(result) // Option.Some(["c", 3])
+ * ```
+ *
+ * @category elements
+ * @since 3.14.0
+ */
+export const findFirst: {
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V, V2 extends V>(refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): (self: Record<K, V>) => Option.Option<[K, V2]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: Record<K, V>) => Option.Option<[K, V]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V, V2 extends V>(
+    self: Record<K, V>,
+    refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2
+  ): Option.Option<[K, V2]>
+  /**
+   * Returns the first entry that satisfies the specified
+   * predicate, or `None` if no such entry exists.
+   *
+   * @example
+   * ```ts
+   * import { Record, Option } from "effect"
+   *
+   * const record = { a: 1, b: 2, c: 3 }
+   * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+   * console.log(result) // Option.Some(["c", 3])
+   * ```
+   *
+   * @category elements
+   * @since 3.14.0
+   */
+  <K extends string | symbol, V>(
+    self: Record<K, V>,
+    predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean
+  ): Option.Option<[K, V]>
+} = dual(
+  2,
+  <K extends string | symbol, V>(self: Record<K, V>, f: (value: V, key: K) => boolean) => {
+    for (const a of Object.entries</**
+     * Returns the first entry that satisfies the specified
+     * predicate, or `None` if no such entry exists.
+     *
+     * @example
+     * ```ts
+     * import { Record, Option } from "effect"
+     *
+     * const record = { a: 1, b: 2, c: 3 }
+     * const result = Record.findFirst(record, (value, key) => value > 1 && key !== "b")
+     * console.log(result) // Option.Some(["c", 3])
+     * ```
+     *
+     * @category elements
+     * @since 3.14.0
+     */
+    V>(self)) {
+      const o = f(a[1], a[0] as K)
+      if (o) {
+        return Option.some(a)
+      }
+    }
+    return Option.none()
+  }
+)

package/src/Schema.ts

@@ -9302,7 +9302,8 @@ export const TaggedError = <Self = never>(identifier?: string) =>
   const schema = getSchemaFromFieldsOr(fieldsOr)
   const newFields = { _tag: getClassTag(tag) }
   const taggedFields = extendFields(newFields, fields)
-  return class TaggedErrorClass extends makeClass({
+  const hasMessageField = "message" in taggedFields
+  class TaggedErrorClass extends makeClass({
     kind: "TaggedError",
     identifier: identifier ?? tag,
     schema: extend(schema, Struct(newFields)),
@@ -9312,13 +9313,23 @@ export const TaggedError = <Self = never>(identifier?: string) =>
     disableToString: true
   }) {
     static _tag = tag
-    get message(): string {
-      return `{ ${
-        util_.ownKeys(fields).map((p: any) => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown(this[p])}`)
-          .join(", ")
-      } }`
-    }
-  } as any
+  }
+
+  if (!hasMessageField) {
+    Object.defineProperty(TaggedErrorClass.prototype, "message", {
+      get() {
+        return `{ ${
+          util_.ownKeys(fields)
+            .map((p: any) => `${util_.formatPropertyKey(p)}: ${util_.formatUnknown((this)[p])}`)
+            .join(", ")
+        } }`
+      },
+      enumerable: false, // mirrors the built-in Error.prototype.message, whose descriptor is also non-enumerable
+      configurable: true
+    })
+  }
+
+  return TaggedErrorClass as any
 }
 
 const extendFields = (a: Struct.Fields, b: Struct.Fields): Struct.Fields => {

package/src/Stream.ts

@@ -9651,6 +9651,46 @@ export const toReadableStreamRuntime: {
   ): ReadableStream<A>
 } = internal.toReadableStreamRuntime
 
+/**
+ * Converts the stream to a `AsyncIterable` using the provided runtime.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterableRuntime: {
+  /**
+   * Converts the stream to a `AsyncIterable` using the provided runtime.
+   *
+   * @since 3.15.0
+   * @category destructors
+   */
+  <A, XR>(runtime: Runtime<XR>): <E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>
+  /**
+   * Converts the stream to a `AsyncIterable` using the provided runtime.
+   *
+   * @since 3.15.0
+   * @category destructors
+   */
+  <A, E, XR, R extends XR>(self: Stream<A, E, R>, runtime: Runtime<XR>): AsyncIterable<A>
+} = internal.toAsyncIterableRuntime
+
+/**
+ * Converts the stream to a `AsyncIterable` capturing the required dependencies.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterableEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<AsyncIterable<A>, never, R> =
+  internal.toAsyncIterableEffect
+
+/**
+ * Converts the stream to a `AsyncIterable`.
+ *
+ * @since 3.15.0
+ * @category destructors
+ */
+export const toAsyncIterable: <A, E>(self: Stream<A, E>) => AsyncIterable<A> = internal.toAsyncIterable
+
 /**
  * Applies the transducer to the stream and emits its outputs.
  *

package/src/Types.ts

@@ -144,6 +144,14 @@ export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
 >() => T extends Y ? 1 : 2 ? true
   : false
 
+/**
+ * Determines if two types are equal, allowing to specify the return types.
+ *
+ * @since 3.15.0
+ * @category models
+ */
+export type EqualsWith<A, B, Y, N> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Y : N
+
 /**
  * Determines if a record contains any of the given keys.
  *
@@ -336,3 +344,8 @@ export type NotFunction<T> = T extends Function ? never : T
  * @since 3.9.0
  */
 export type NoExcessProperties<T, U> = T & { readonly [K in Exclude<keyof U, keyof T>]: never }
+
+/**
+ * @since 3.15.0
+ */
+export type Ctor<T = {}> = new(...args: Array<any>) => T

package/src/internal/configError.ts

@@ -32,6 +32,12 @@ export const And = (self: ConfigError.ConfigError, that: ConfigError.ConfigError
       return `${this.left} and ${this.right}`
     }
   })
+  Object.defineProperty(error, "message", {
+    enumerable: false,
+    get(this: ConfigError.And) {
+      return this.toString()
+    }
+  })
   return error
 }
 
@@ -47,6 +53,12 @@ export const Or = (self: ConfigError.ConfigError, that: ConfigError.ConfigError)
       return `${this.left} or ${this.right}`
     }
   })
+  Object.defineProperty(error, "message", {
+    enumerable: false,
+    get(this: ConfigError.Or) {
+      return this.toString()
+    }
+  })
   return error
 }