effect 3.8.4 → 3.8.5

package/src/Tuple.ts

@@ -80,14 +80,55 @@ export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
  * @since 2.0.0
  */
 export const mapBoth: {
-  <L1, L2, R1, R2>(options: {
-    readonly onFirst: (e: L1) => L2
-    readonly onSecond: (a: R1) => R2
-  }): (self: readonly [L1, R1]) => [L2, R2]
-  <L1, R1, L2, R2>(self: readonly [L1, R1], options: {
-    readonly onFirst: (e: L1) => L2
-    readonly onSecond: (a: R1) => R2
-  }): [L2, R2]
+  /**
+   * Transforms both elements of a tuple using the given functions.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the first element of the tuple.
+   * @param g - The function to transform the second element of the tuple.
+   *
+   * @example
+   * import { mapBoth } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapBoth(["hello", 42], { onFirst: s => s.toUpperCase(), onSecond: n => n.toString() }),
+   *   ["HELLO", "42"]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
+  <L1, L2, R1, R2>(
+    options: {
+      readonly onFirst: (e: L1) => L2
+      readonly onSecond: (a: R1) => R2
+    }
+  ): (self: readonly [L1, R1]) => [L2, R2]
+  /**
+   * Transforms both elements of a tuple using the given functions.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the first element of the tuple.
+   * @param g - The function to transform the second element of the tuple.
+   *
+   * @example
+   * import { mapBoth } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapBoth(["hello", 42], { onFirst: s => s.toUpperCase(), onSecond: n => n.toString() }),
+   *   ["HELLO", "42"]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
+  <L1, R1, L2, R2>(
+    self: readonly [L1, R1],
+    options: {
+      readonly onFirst: (e: L1) => L2
+      readonly onSecond: (a: R1) => R2
+    }
+  ): [L2, R2]
 } = dual(
   2,
   <L1, R1, L2, R2>(
@@ -117,7 +158,41 @@ export const mapBoth: {
  * @since 2.0.0
  */
 export const mapFirst: {
+  /**
+   * Transforms the first component of a tuple using a given function.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the first element of the tuple.
+   *
+   * @example
+   * import { mapFirst } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapFirst(["hello", 42], s => s.toUpperCase()),
+   *   ["HELLO", 42]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
   <L1, L2>(f: (left: L1) => L2): <R>(self: readonly [L1, R]) => [L2, R]
+  /**
+   * Transforms the first component of a tuple using a given function.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the first element of the tuple.
+   *
+   * @example
+   * import { mapFirst } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapFirst(["hello", 42], s => s.toUpperCase()),
+   *   ["HELLO", 42]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
   <L1, R, L2>(self: readonly [L1, R], f: (left: L1) => L2): [L2, R]
 } = dual(2, <L1, R, L2>(self: readonly [L1, R], f: (left: L1) => L2): [L2, R] => [f(self[0]), self[1]])
 
@@ -139,7 +214,41 @@ export const mapFirst: {
  * @since 2.0.0
  */
 export const mapSecond: {
+  /**
+   * Transforms the second component of a tuple using a given function.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the second element of the tuple.
+   *
+   * @example
+   * import { mapSecond } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapSecond(["hello", 42], n => n.toString()),
+   *   ["hello", "42"]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
   <R1, R2>(f: (right: R1) => R2): <L>(self: readonly [L, R1]) => [L, R2]
+  /**
+   * Transforms the second component of a tuple using a given function.
+   *
+   * @param self - A tuple of length `2`.
+   * @param f - The function to transform the second element of the tuple.
+   *
+   * @example
+   * import { mapSecond } from "effect/Tuple"
+   *
+   * assert.deepStrictEqual(
+   *   mapSecond(["hello", 42], n => n.toString()),
+   *   ["hello", "42"]
+   * )
+   *
+   * @category mapping
+   * @since 2.0.0
+   */
   <L, R1, R2>(self: readonly [L, R1], f: (right: R1) => R2): [L, R2]
 } = dual(2, <L, R1, R2>(self: readonly [L, R1], f: (right: R1) => R2): [L, R2] => [self[0], f(self[1])])
 
@@ -190,7 +299,19 @@ export const getOrder: <T extends ReadonlyArray<order.Order<any>>>(
  * @since 2.0.0
  */
 export const appendElement: {
+  /**
+   * Appends an element to the end of a tuple.
+   *
+   * @category concatenating
+   * @since 2.0.0
+   */
   <B>(that: B): <A extends ReadonlyArray<unknown>>(self: A) => [...A, B]
+  /**
+   * Appends an element to the end of a tuple.
+   *
+   * @category concatenating
+   * @since 2.0.0
+   */
   <A extends ReadonlyArray<unknown>, B>(self: A, that: B): [...A, B]
 } = dual(2, <A extends ReadonlyArray<unknown>, B>(self: A, that: B): [...A, B] => [...self, that])
 
@@ -209,7 +330,35 @@ export const appendElement: {
  * @since 3.4.0
  */
 export const at: {
+  /**
+   * Retrieves the element at a specified index from a tuple.
+   *
+   * @param self - A tuple from which to retrieve the element.
+   * @param index - The index of the element to retrieve.
+   *
+   * @example
+   * import { Tuple } from "effect"
+   *
+   * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+   *
+   * @category getters
+   * @since 3.4.0
+   */
   <N extends number>(index: N): <A extends ReadonlyArray<unknown>>(self: A) => A[N]
+  /**
+   * Retrieves the element at a specified index from a tuple.
+   *
+   * @param self - A tuple from which to retrieve the element.
+   * @param index - The index of the element to retrieve.
+   *
+   * @example
+   * import { Tuple } from "effect"
+   *
+   * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+   *
+   * @category getters
+   * @since 3.4.0
+   */
   <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N]
 } = dual(2, <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N] => self[index])
 

package/src/Unify.ts

@@ -76,6 +76,9 @@ export type Unify<A> = Values<
  * @since 2.0.0
  */
 export const unify: {
+  /**
+   * @since 2.0.0
+   */
   <
     Args extends Array<any>,
     Args2 extends Array<any>,
@@ -86,6 +89,9 @@ export const unify: {
   >(
     x: (...args: Args) => (...args: Args2) => (...args: Args3) => (...args: Args4) => (...args: Args5) => T
   ): (...args: Args) => (...args: Args2) => (...args: Args3) => (...args: Args4) => (...args: Args5) => Unify<T>
+  /**
+   * @since 2.0.0
+   */
   <
     Args extends Array<any>,
     Args2 extends Array<any>,
@@ -95,6 +101,9 @@ export const unify: {
   >(
     x: (...args: Args) => (...args: Args2) => (...args: Args3) => (...args: Args4) => T
   ): (...args: Args) => (...args: Args2) => (...args: Args3) => (...args: Args4) => Unify<T>
+  /**
+   * @since 2.0.0
+   */
   <
     Args extends Array<any>,
     Args2 extends Array<any>,
@@ -103,16 +112,23 @@ export const unify: {
   >(
     x: (...args: Args) => (...args: Args2) => (...args: Args3) => T
   ): (...args: Args) => (...args: Args2) => (...args: Args3) => Unify<T>
+  /**
+   * @since 2.0.0
+   */
   <
     Args extends Array<any>,
     Args2 extends Array<any>,
     T
-  >(
-    x: (...args: Args) => (...args: Args2) => T
-  ): (...args: Args) => (...args: Args2) => Unify<T>
+  >(x: (...args: Args) => (...args: Args2) => T): (...args: Args) => (...args: Args2) => Unify<T>
+  /**
+   * @since 2.0.0
+   */
   <
     Args extends Array<any>,
     T
   >(x: (...args: Args) => T): (...args: Args) => Unify<T>
+  /**
+   * @since 2.0.0
+   */
   <T>(x: T): Unify<T>
 } = identity as any

package/src/UpstreamPullRequest.ts

@@ -101,12 +101,24 @@ export const isNoUpstream: <A>(self: UpstreamPullRequest<A>) => self is NoUpstre
  * @category folding
  */
 export const match: {
+  /**
+   * Folds an `UpstreamPullRequest<A>` into a value of type `Z`.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <A, Z>(
     options: {
       readonly onPulled: (value: A) => Z
       readonly onNoUpstream: (activeDownstreamCount: number) => Z
     }
   ): (self: UpstreamPullRequest<A>) => Z
+  /**
+   * Folds an `UpstreamPullRequest<A>` into a value of type `Z`.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <A, Z>(
     self: UpstreamPullRequest<A>,
     options: {

package/src/UpstreamPullStrategy.ts

@@ -105,12 +105,24 @@ export const isPullAfterAllEnqueued: <A>(self: UpstreamPullStrategy<A>) => self
  * @category folding
  */
 export const match: {
+  /**
+   * Folds an `UpstreamPullStrategy<A>` into a value of type `Z`.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <A, Z>(
     options: {
       readonly onNext: (emitSeparator: Option.Option<A>) => Z
       readonly onAllEnqueued: (emitSeparator: Option.Option<A>) => Z
     }
   ): (self: UpstreamPullStrategy<A>) => Z
+  /**
+   * Folds an `UpstreamPullStrategy<A>` into a value of type `Z`.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <A, Z>(
     self: UpstreamPullStrategy<A>,
     options: {

package/src/Utils.ts

@@ -614,21 +614,7 @@ export class PCGRandom {
    * @since 2.0.0
    */
   integer(max: number) {
-    if (!max) {
-      return this._next()
-    }
-    max = max >>> 0
-    if ((max & (max - 1)) === 0) {
-      return this._next() & (max - 1) // fast path for power of 2
-    }
-
-    let num = 0
-    const skew = (-max >>> 0) % max >>> 0
-    for (num = this._next(); num < skew; num = this._next()) {
-      // this loop will rarely execute more than twice,
-      // and is intentionally empty
-    }
-    return num % max
+    return Math.round(this.number() * Number.MAX_SAFE_INTEGER) % max
   }
 
   /**

package/src/internal/core.ts

@@ -673,7 +673,7 @@ export const originalInstance = <E>(obj: E): E => {
 }
 
 /* @internal */
-const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E => {
+export const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E => {
   if (Option.isSome(span)) {
     return new Proxy(obj, {
       has(target, p) {

package/src/internal/runtime.ts

@@ -250,7 +250,7 @@ export const unsafeRunSyncExit =
     if (result) {
       return result
     }
-    throw asyncFiberException(fiberRuntime)
+    return core.exitDie(core.capture(asyncFiberException(fiberRuntime), core.currentSpanFromFiber(fiberRuntime)))
   }
 
 /** @internal */

package/src/internal/stream.ts

@@ -4107,6 +4107,33 @@ export const mergeAll = dual<
   }) => Stream.Stream<A, E, R>
 >((args) => Symbol.iterator in args[0], (streams, options) => flatten(fromIterable(streams), options))
 
+/** @internal */
+export const mergeWithTag: {
+  <S extends { [k in string]: Stream.Stream<any, any, any> }>(
+    streams: S,
+    options: {
+      readonly concurrency: number | "unbounded"
+      readonly bufferSize?: number | undefined
+    }
+  ): Stream.Stream<
+    { [K in keyof S]: { _tag: K; value: Stream.Stream.Success<S[K]> } }[keyof S],
+    Stream.Stream.Error<S[keyof S]>,
+    Stream.Stream.Context<S[keyof S]>
+  >
+  (options: {
+    readonly concurrency: number | "unbounded"
+    readonly bufferSize?: number | undefined
+  }): <S extends { [k in string]: Stream.Stream<any, any, any> }>(streams: S) => Stream.Stream<
+    { [K in keyof S]: { _tag: K; value: Stream.Stream.Success<S[K]> } }[keyof S],
+    Stream.Stream.Error<S[keyof S]>,
+    Stream.Stream.Context<S[keyof S]>
+  >
+} = dual(2, (streams, options) => {
+  const keys = Object.keys(streams)
+  const values = keys.map((key) => streams[key].pipe(map((value) => ({ _tag: key, value })))) as any
+  return mergeAll(values, options)
+})
+
 /** @internal */
 export const mergeEither = dual<
   <A2, E2, R2>(

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.8.4"
+let moduleVersion = "3.8.5"
 
 export const getCurrentVersion = () => moduleVersion