effect 3.8.4 → 3.9.0

package/src/Order.ts

@@ -78,7 +78,15 @@ export const reverse = <A>(O: Order<A>): Order<A> => make((self, that) => O(that
  * @since 2.0.0
  */
 export const combine: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(that: Order<A>): (self: Order<A>) => Order<A>
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(self: Order<A>, that: Order<A>): Order<A>
 } = dual(2, <A>(self: Order<A>, that: Order<A>): Order<A> =>
   make((a1, a2) => {
@@ -94,7 +102,15 @@ export const combine: {
  * @since 2.0.0
  */
 export const combineMany: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<A>
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<A>
 } = dual(2, <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<A> =>
   make((a1, a2) => {
@@ -127,7 +143,15 @@ export const combineAll = <A>(collection: Iterable<Order<A>>): Order<A> => combi
  * @since 2.0.0
  */
 export const mapInput: {
+  /**
+   * @category mapping
+   * @since 2.0.0
+   */
   <B, A>(f: (b: B) => A): (self: Order<A>) => Order<B>
+  /**
+   * @category mapping
+   * @since 2.0.0
+   */
   <A, B>(self: Order<A>, f: (b: B) => A): Order<B>
 } = dual(
   2,

package/src/Ordering.ts

@@ -52,6 +52,31 @@ export const reverse = (o: Ordering): Ordering => (o === -1 ? 1 : o === 1 ? -1 :
  * @since 2.0.0
  */
 export const match: {
+  /**
+   * Depending on the `Ordering` parameter given to it, returns a value produced by one of the 3 functions provided as parameters.
+   *
+   * @param self - The `Ordering` parameter to match against.
+   * @param onLessThan - A function that will be called if the `Ordering` parameter is `-1`.
+   * @param onEqual - A function that will be called if the `Ordering` parameter is `0`.
+   * @param onGreaterThan - A function that will be called if the `Ordering` parameter is `1`.
+   *
+   * @example
+   * import { Ordering } from "effect"
+   * import { constant } from "effect/Function"
+   *
+   * const toMessage = Ordering.match({
+   *   onLessThan: constant('less than'),
+   *   onEqual: constant('equal'),
+   *   onGreaterThan: constant('greater than')
+   * })
+   *
+   * assert.deepStrictEqual(toMessage(-1), "less than")
+   * assert.deepStrictEqual(toMessage(0), "equal")
+   * assert.deepStrictEqual(toMessage(1), "greater than")
+   *
+   * @category pattern matching
+   * @since 2.0.0
+   */
   <A, B, C = B>(
     options: {
       readonly onLessThan: LazyArg<A>
@@ -59,6 +84,31 @@ export const match: {
       readonly onGreaterThan: LazyArg<C>
     }
   ): (self: Ordering) => A | B | C
+  /**
+   * Depending on the `Ordering` parameter given to it, returns a value produced by one of the 3 functions provided as parameters.
+   *
+   * @param self - The `Ordering` parameter to match against.
+   * @param onLessThan - A function that will be called if the `Ordering` parameter is `-1`.
+   * @param onEqual - A function that will be called if the `Ordering` parameter is `0`.
+   * @param onGreaterThan - A function that will be called if the `Ordering` parameter is `1`.
+   *
+   * @example
+   * import { Ordering } from "effect"
+   * import { constant } from "effect/Function"
+   *
+   * const toMessage = Ordering.match({
+   *   onLessThan: constant('less than'),
+   *   onEqual: constant('equal'),
+   *   onGreaterThan: constant('greater than')
+   * })
+   *
+   * assert.deepStrictEqual(toMessage(-1), "less than")
+   * assert.deepStrictEqual(toMessage(0), "equal")
+   * assert.deepStrictEqual(toMessage(1), "greater than")
+   *
+   * @category pattern matching
+   * @since 2.0.0
+   */
   <A, B, C = B>(
     o: Ordering,
     options: {
@@ -81,7 +131,15 @@ export const match: {
  * @since 2.0.0
  */
 export const combine: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   (that: Ordering): (self: Ordering) => Ordering
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   (self: Ordering, that: Ordering): Ordering
 } = dual(2, (self: Ordering, that: Ordering): Ordering => self !== 0 ? self : that)
 
@@ -90,7 +148,15 @@ export const combine: {
  * @since 2.0.0
  */
 export const combineMany: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   (collection: Iterable<Ordering>): (self: Ordering) => Ordering
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   (self: Ordering, collection: Iterable<Ordering>): Ordering
 } = dual(2, (self: Ordering, collection: Iterable<Ordering>): Ordering => {
   let ordering = self

package/src/Pipeable.ts

@@ -8,11 +8,17 @@
  */
 export interface Pipeable {
   pipe<A>(this: A): A
-  pipe<A, B>(this: A, ab: (_: A) => B): B
-  pipe<A, B, C>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
-  pipe<A, B, C, D>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D
-  pipe<A, B, C, D, E>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E
-  pipe<A, B, C, D, E, F>(
+  pipe<A, B = never>(this: A, ab: (_: A) => B): B
+  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C
+  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D
+  pipe<A, B = never, C = never, D = never, E = never>(
+    this: A,
+    ab: (_: A) => B,
+    bc: (_: B) => C,
+    cd: (_: C) => D,
+    de: (_: D) => E
+  ): E
+  pipe<A, B = never, C = never, D = never, E = never, F = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -20,7 +26,7 @@ export interface Pipeable {
     de: (_: D) => E,
     ef: (_: E) => F
   ): F
-  pipe<A, B, C, D, E, F, G>(
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -29,7 +35,7 @@ export interface Pipeable {
     ef: (_: E) => F,
     fg: (_: F) => G
   ): G
-  pipe<A, B, C, D, E, F, G, H>(
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -39,7 +45,7 @@ export interface Pipeable {
     fg: (_: F) => G,
     gh: (_: G) => H
   ): H
-  pipe<A, B, C, D, E, F, G, H, I>(
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -50,7 +56,7 @@ export interface Pipeable {
     gh: (_: G) => H,
     hi: (_: H) => I
   ): I
-  pipe<A, B, C, D, E, F, G, H, I, J>(
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -62,7 +68,7 @@ export interface Pipeable {
     hi: (_: H) => I,
     ij: (_: I) => J
   ): J
-  pipe<A, B, C, D, E, F, G, H, I, J, K>(
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -75,7 +81,20 @@ export interface Pipeable {
     ij: (_: I) => J,
     jk: (_: J) => K
   ): K
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -89,7 +108,21 @@ export interface Pipeable {
     jk: (_: J) => K,
     kl: (_: K) => L
   ): L
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -104,7 +137,22 @@ export interface Pipeable {
     kl: (_: K) => L,
     lm: (_: L) => M
   ): M
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -120,7 +168,23 @@ export interface Pipeable {
     lm: (_: L) => M,
     mn: (_: M) => N
   ): N
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -137,7 +201,24 @@ export interface Pipeable {
     mn: (_: M) => N,
     no: (_: N) => O
   ): O
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -155,7 +236,25 @@ export interface Pipeable {
     no: (_: N) => O,
     op: (_: O) => P
   ): P
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -174,7 +273,26 @@ export interface Pipeable {
     op: (_: O) => P,
     pq: (_: P) => Q
   ): Q
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never,
+    R = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -194,7 +312,27 @@ export interface Pipeable {
     pq: (_: P) => Q,
     qr: (_: Q) => R
   ): R
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never,
+    R = never,
+    S = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -215,7 +353,28 @@ export interface Pipeable {
     qr: (_: Q) => R,
     rs: (_: R) => S
   ): S
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never,
+    R = never,
+    S = never,
+    T = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -237,7 +396,29 @@ export interface Pipeable {
     rs: (_: R) => S,
     st: (_: S) => T
   ): T
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never,
+    R = never,
+    S = never,
+    T = never,
+    U = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,
@@ -260,7 +441,29 @@ export interface Pipeable {
     st: (_: S) => T,
     tu: (_: T) => U
   ): U
-  pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
+  pipe<
+    A,
+    B = never,
+    C = never,
+    D = never,
+    E = never,
+    F = never,
+    G = never,
+    H = never,
+    I = never,
+    J = never,
+    K = never,
+    L = never,
+    M = never,
+    N = never,
+    O = never,
+    P = never,
+    Q = never,
+    R = never,
+    S = never,
+    T = never,
+    U = never
+  >(
     this: A,
     ab: (_: A) => B,
     bc: (_: B) => C,

package/src/Pool.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/pool.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
 import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
 
 /**
  * @since 2.0.0
@@ -28,7 +29,7 @@ export type PoolTypeId = typeof PoolTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Pipeable {
+export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Effect.Effect<A, E, Scope.Scope>, Pipeable {
   /**
    * Retrieves an item from the pool in a scoped effect. Note that if
    * acquisition fails, then the returned effect will fail for that same reason.
@@ -42,6 +43,30 @@ export interface Pool<in out A, out E = never> extends Pool.Variance<A, E>, Pipe
    * than eagerly.
    */
   invalidate(item: A): Effect.Effect<void>
+
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: PoolUnify<this>
+  readonly [Unify.ignoreSymbol]?: PoolUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface PoolUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Pool?: () => Extract<A[Unify.typeSymbol], Pool<any, any>> extends Pool<infer A0, infer _E0> | infer _ ?
+    A0 extends any ? Extract<A[Unify.typeSymbol], Pool<A0, any>> extends Pool<A0, infer E1> ? Pool<A0, E1>
+      : never
+    : never :
+    never
+}
+
+/**
+ * @category models
+ * @since 3.9.0
+ */
+export interface PoolUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
 }
 
 /**
@@ -174,6 +199,22 @@ export const get: <A, E>(self: Pool<A, E>) => Effect.Effect<A, E, Scope.Scope> =
  * @category combinators
  */
 export const invalidate: {
+  /**
+   * Invalidates the specified item. This will cause the pool to eventually
+   * reallocate the item, although this reallocation may occur lazily rather
+   * than eagerly.
+   *
+   * @since 2.0.0
+   * @category combinators
+   */
   <A>(value: A): <E>(self: Pool<A, E>) => Effect.Effect<void, never, Scope.Scope>
+  /**
+   * Invalidates the specified item. This will cause the pool to eventually
+   * reallocate the item, although this reallocation may occur lazily rather
+   * than eagerly.
+   *
+   * @since 2.0.0
+   * @category combinators
+   */
   <A, E>(self: Pool<A, E>, value: A): Effect.Effect<void, never, Scope.Scope>
 } = internal.invalidate