effect 3.8.4 → 3.9.0

package/src/Tuple.ts

@@ -7,6 +7,7 @@ import * as Equivalence from "./Equivalence.js"
 import { dual } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as order from "./Order.js"
+import type { TupleOf } from "./Types.js"
 
 /**
  * @category type lambdas
@@ -61,6 +62,71 @@ export const getFirst = <L, R>(self: readonly [L, R]): L => self[0]
  */
 export const getSecond = <L, R>(self: readonly [L, R]): R => self[1]
 
+/**
+ * Transforms each element of tuple using the given function, treating tuple homomorphically
+ *
+ * @param self - A tuple.
+ * @param f - The function to transform elements of the tuple.
+ *
+ * @example
+ * import { pipe, Tuple } from "effect"
+ *
+ * const result = pipe(
+ *   ["a", 1, false] as const,
+ *   Tuple.map((el) => el.toString().toUpperCase())
+ * )
+ * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+ *
+ * @category mapping
+ * @since 3.9.0
+ */
+export const map: {
+  /**
+   * Transforms each element of tuple using the given function, treating tuple homomorphically
+   *
+   * @param self - A tuple.
+   * @param f - The function to transform elements of the tuple.
+   *
+   * @example
+   * import { pipe, Tuple } from "effect"
+   *
+   * const result = pipe(
+   *   ["a", 1, false] as const,
+   *   Tuple.map((el) => el.toString().toUpperCase())
+   * )
+   * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   *
+   * @category mapping
+   * @since 3.9.0
+   */
+  <T extends ReadonlyArray<any> | [], B>(fn: (element: T[number]) => B): (self: T) => TupleOf<T["length"], B>
+  /**
+   * Transforms each element of tuple using the given function, treating tuple homomorphically
+   *
+   * @param self - A tuple.
+   * @param f - The function to transform elements of the tuple.
+   *
+   * @example
+   * import { pipe, Tuple } from "effect"
+   *
+   * const result = pipe(
+   *   ["a", 1, false] as const,
+   *   Tuple.map((el) => el.toString().toUpperCase())
+   * )
+   * assert.deepStrictEqual(result, ['A', '1', 'FALSE'])
+   *
+   * @category mapping
+   * @since 3.9.0
+   */
+  <B, T extends ReadonlyArray<any> | []>(self: T, fn: (element: T[number]) => B): TupleOf<T["length"], B>
+} = dual(
+  2,
+  <N extends number, A, B>(
+    self: TupleOf<N, A>,
+    fn: (element: A) => B
+  ): TupleOf<N, B> => self.map((element) => fn(element)) as TupleOf<N, B>
+)
+
 /**
  * Transforms both elements of a tuple using the given functions.
  *
@@ -80,14 +146,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 +224,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 +280,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 +365,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 +396,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/Types.ts

@@ -254,6 +254,18 @@ export type NoInfer<A> = [A][A extends any ? 0 : never]
  */
 export type Invariant<A> = (_: A) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Invariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Invariant<infer U> ? U : never
+}
+
 /**
  * Covariant helper.
  *
@@ -262,6 +274,18 @@ export type Invariant<A> = (_: A) => A
  */
 export type Covariant<A> = (_: never) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Covariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Covariant<infer U> ? U : never
+}
+
 /**
  * Contravariant helper.
  *
@@ -270,6 +294,18 @@ export type Covariant<A> = (_: never) => A
  */
 export type Contravariant<A> = (_: A) => void
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Contravariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Contravariant<infer U> ? U : never
+}
+
 /**
  * @since 2.0.0
  */
@@ -279,3 +315,8 @@ export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
  * @since 2.0.0
  */
 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 }

package/src/Unify.ts

@@ -34,26 +34,21 @@ export declare const ignoreSymbol: unique symbol
  */
 export type ignoreSymbol = typeof ignoreSymbol
 
-type MaybeReturn<F> = F extends () => any ? ReturnType<F> : F
+type MaybeReturn<F> = F extends () => infer R ? R : NonNullable<F>
 
-type Values<X extends [any, any]> = X extends any
-  ? { [k in keyof X[0]]-?: k extends X[1] ? never : MaybeReturn<X[0][k]> }[keyof X[0]]
+type Values<X extends [any, any]> = X extends [infer A, infer Ignore]
+  ? Exclude<keyof A, Ignore> extends infer k ? k extends keyof A ? MaybeReturn<A[k]> : never : never
   : never
 
-type Ignore<X> = X extends {
-  [ignoreSymbol]?: any
-} ? keyof NonNullable<X[ignoreSymbol]>
+type Ignore<X> = X extends { [ignoreSymbol]?: infer Obj } ? keyof NonNullable<Obj>
   : never
 
 type ExtractTypes<
-  X extends {
-    [typeSymbol]?: any
-    [unifySymbol]?: any
-  }
-> = X extends any ? [
-    NonNullable<X[unifySymbol]>,
-    Ignore<X>
-  ]
+  X
+> = X extends {
+  [typeSymbol]?: infer _Type
+  [unifySymbol]?: infer _Unify
+} ? [NonNullable<_Unify>, Ignore<X>]
   : never
 
 type FilterIn<A> = A extends any ? typeSymbol extends keyof A ? A : never : never
@@ -76,6 +71,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 +84,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 +96,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 +107,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/cause.ts

@@ -8,7 +8,7 @@ import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
@@ -69,6 +69,9 @@ const proto = {
   toString<E>(this: Cause.Cause<E>) {
     return pretty(this)
   },
+  [DenoInspectSymbol]<E>(this: Cause.Cause<E>) {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]<E>(this: Cause.Cause<E>) {
     return this.toJSON()
   }

package/src/internal/context.ts

@@ -3,7 +3,7 @@ import * as Equal from "../Equal.js"
 import type { LazyArg } from "../Function.js"
 import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as O from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -25,7 +25,6 @@ export const STMTypeId: STM.STMTypeId = Symbol.for(
 /** @internal */
 export const TagProto: any = {
   ...EffectPrototype,
-  _tag: "Tag",
   _op: "Tag",
   [STMTypeId]: effectVariance,
   [TagTypeId]: {
@@ -42,6 +41,9 @@ export const TagProto: any = {
       stack: this.stack
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },
@@ -126,6 +128,9 @@ export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
       services: Array.from(this.unsafeMap).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return (this as any).toJSON()
+  },
   [NodeInspectSymbol]() {
     return (this as any).toJSON()
   }

package/src/internal/core-effect.ts

@@ -1055,17 +1055,17 @@ const loopDiscard = <S, X, E, R>(
 
 /* @internal */
 export const mapAccum: {
-  <S, A, B, E, R>(
+  <S, A, B, E, R, I extends Iterable<A> = Iterable<A>>(
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): (elements: Iterable<A>) => Effect.Effect<[S, Array<B>], E, R>
-  <A, S, B, E, R>(
-    elements: Iterable<A>,
+  ): (elements: I) => Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+  <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+    elements: I,
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): Effect.Effect<[S, Array<B>], E, R>
-} = dual(3, <A, S, B, E, R>(
-  elements: Iterable<A>,
+  ): Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+} = dual(3, <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+  elements: I,
   zero: S,
   f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
 ): Effect.Effect<[S, Array<B>], E, R> =>

package/src/internal/core.ts

@@ -21,7 +21,7 @@ import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashMap from "../HashMap.js"
 import type * as HashSet from "../HashSet.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as LogLevel from "../LogLevel.js"
 import type * as LogSpan from "../LogSpan.js"
@@ -177,6 +177,9 @@ class EffectPrimitive {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -226,6 +229,9 @@ class EffectPrimitiveFailure {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -275,6 +281,9 @@ class EffectPrimitiveSuccess {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -673,7 +682,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) {
@@ -2194,6 +2203,9 @@ export const YieldableError: new(message?: string, options?: ErrorOptions) => Ca
     toJSON() {
       return { ...this }
     }
+    [DenoInspectSymbol]() {
+      return this[NodeInspectSymbol]()
+    }
     [NodeInspectSymbol]() {
       if (this.toString !== globalThis.Error.prototype.toString) {
         return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString()

package/src/internal/effect/circular.ts

@@ -112,10 +112,16 @@ export const unsafeMakeSemaphore = (permits: number): Semaphore => new Semaphore
 /** @internal */
 export const makeSemaphore = (permits: number) => core.sync(() => unsafeMakeSemaphore(permits))
 
-class Latch implements Effect.Latch {
+class Latch extends Effectable.Class<void> implements Effect.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
   scheduled = false
-  constructor(private isOpen: boolean) {}
+  constructor(private isOpen: boolean) {
+    super()
+  }
+
+  commit() {
+    return this.await
+  }
 
   private unsafeSchedule(fiber: Fiber.RuntimeFiber<void>) {
     if (this.scheduled || this.waiters.length === 0) {