effect 3.8.4 → 3.9.0

package/src/Predicate.ts

@@ -88,7 +88,45 @@ export declare namespace Refinement {
  * @since 2.0.0
  */
 export const mapInput: {
+  /**
+   * Given a `Predicate<A>` returns a `Predicate<B>`
+   *
+   * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
+   * @param f - a function to transform `B` to `A`.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
+   *
+   * assert.deepStrictEqual(minLength3("a"), false)
+   * assert.deepStrictEqual(minLength3("aa"), false)
+   * assert.deepStrictEqual(minLength3("aaa"), true)
+   * assert.deepStrictEqual(minLength3("aaaa"), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <B, A>(f: (b: B) => A): (self: Predicate<A>) => Predicate<B>
+  /**
+   * Given a `Predicate<A>` returns a `Predicate<B>`
+   *
+   * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
+   * @param f - a function to transform `B` to `A`.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
+   *
+   * assert.deepStrictEqual(minLength3("a"), false)
+   * assert.deepStrictEqual(minLength3("aa"), false)
+   * assert.deepStrictEqual(minLength3("aaa"), true)
+   * assert.deepStrictEqual(minLength3("aaaa"), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>
 } = dual(2, <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B> => (b) => self(f(b)))
 
@@ -117,7 +155,55 @@ export const mapInput: {
  * @since 3.3.0
  */
 export const isTupleOf: {
+  /**
+   * Determine if an `Array` is a tuple with exactly `N` elements, narrowing down the type to `TupleOf`.
+   *
+   * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
+   *
+   * @example
+   * import { isTupleOf } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 2), false);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3];
+   * if (isTupleOf(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
   <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOf<N, T>
+  /**
+   * Determine if an `Array` is a tuple with exactly `N` elements, narrowing down the type to `TupleOf`.
+   *
+   * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
+   *
+   * @example
+   * import { isTupleOf } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 2), false);
+   * assert.deepStrictEqual(isTupleOf([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3];
+   * if (isTupleOf(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
   <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T>
 } = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOf<N, T> => self.length === n)
 
@@ -146,7 +232,55 @@ export const isTupleOf: {
  * @since 3.3.0
  */
 export const isTupleOfAtLeast: {
+  /**
+   * Determine if an `Array` is a tuple with at least `N` elements, narrowing down the type to `TupleOfAtLeast`.
+   *
+   * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
+   *
+   * @example
+   * import { isTupleOfAtLeast } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 2), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3, 4];
+   * if (isTupleOfAtLeast(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number, ...number[]]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
   <N extends number>(n: N): <T>(self: ReadonlyArray<T>) => self is TupleOfAtLeast<N, T>
+  /**
+   * Determine if an `Array` is a tuple with at least `N` elements, narrowing down the type to `TupleOfAtLeast`.
+   *
+   * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
+   *
+   * @param self - The `Array` to check.
+   * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
+   *
+   * @example
+   * import { isTupleOfAtLeast } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 2), true);
+   * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 4), false);
+   *
+   * const arr: number[] = [1, 2, 3, 4];
+   * if (isTupleOfAtLeast(arr, 3)) {
+   *   console.log(arr);
+   *   // ^? [number, number, number, ...number[]]
+   * }
+   *
+   * @category guards
+   * @since 3.3.0
+   */
   <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T>
 } = dual(2, <T, N extends number>(self: ReadonlyArray<T>, n: N): self is TupleOfAtLeast<N, T> => self.length >= n)
 
@@ -446,7 +580,25 @@ export const isObject = (input: unknown): input is object => isRecordOrArray(inp
  * @since 2.0.0
  */
 export const hasProperty: {
+  /**
+   * Checks whether a value is an `object` containing a specified property key.
+   *
+   * @param property - The field to check within the object.
+   * @param self - The value to examine.
+   *
+   * @category guards
+   * @since 2.0.0
+   */
   <P extends PropertyKey>(property: P): (self: unknown) => self is { [K in P]: unknown }
+  /**
+   * Checks whether a value is an `object` containing a specified property key.
+   *
+   * @param property - The field to check within the object.
+   * @param self - The value to examine.
+   *
+   * @category guards
+   * @since 2.0.0
+   */
   <P extends PropertyKey>(self: unknown, property: P): self is { [K in P]: unknown }
 } = dual(
   2,
@@ -474,7 +626,45 @@ export const hasProperty: {
  * @since 2.0.0
  */
 export const isTagged: {
+  /**
+   * Tests if a value is an `object` with a property `_tag` that matches the given tag.
+   *
+   * @param input - The value to test.
+   * @param tag - The tag to test for.
+   *
+   * @example
+   * import { isTagged } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTagged(1, "a"), false)
+   * assert.deepStrictEqual(isTagged(null, "a"), false)
+   * assert.deepStrictEqual(isTagged({}, "a"), false)
+   * assert.deepStrictEqual(isTagged({ a: "a" }, "a"), false)
+   * assert.deepStrictEqual(isTagged({ _tag: "a" }, "a"), true)
+   * assert.deepStrictEqual(isTagged("a")({ _tag: "a" }), true)
+   *
+   * @category guards
+   * @since 2.0.0
+   */
   <K extends string>(tag: K): (self: unknown) => self is { _tag: K }
+  /**
+   * Tests if a value is an `object` with a property `_tag` that matches the given tag.
+   *
+   * @param input - The value to test.
+   * @param tag - The tag to test for.
+   *
+   * @example
+   * import { isTagged } from "effect/Predicate"
+   *
+   * assert.deepStrictEqual(isTagged(1, "a"), false)
+   * assert.deepStrictEqual(isTagged(null, "a"), false)
+   * assert.deepStrictEqual(isTagged({}, "a"), false)
+   * assert.deepStrictEqual(isTagged({ a: "a" }, "a"), false)
+   * assert.deepStrictEqual(isTagged({ _tag: "a" }, "a"), true)
+   * assert.deepStrictEqual(isTagged("a")({ _tag: "a" }), true)
+   *
+   * @category guards
+   * @since 2.0.0
+   */
   <K extends string>(self: unknown, tag: K): self is { _tag: K }
 } = dual(
   2,
@@ -665,13 +855,41 @@ export const isPromiseLike = (
   input: unknown
 ): input is PromiseLike<unknown> => hasProperty(input, "then") && isFunction(input.then)
 
+/**
+ * Tests if a value is a `RegExp`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { Predicate } from "effect"
+ *
+ * assert.deepStrictEqual(Predicate.isRegExp(/a/), true)
+ * assert.deepStrictEqual(Predicate.isRegExp("a"), false)
+ *
+ * @category guards
+ * @since 3.9.0
+ */
+export const isRegExp = (input: unknown): input is RegExp => input instanceof RegExp
+
 /**
  * @since 2.0.0
  */
 export const compose: {
+  /**
+   * @since 2.0.0
+   */
   <A, B extends A, C extends B>(bc: Refinement<B, C>): (ab: Refinement<A, B>) => Refinement<A, C>
+  /**
+   * @since 2.0.0
+   */
   <A, B extends A>(bc: Predicate<NoInfer<B>>): (ab: Refinement<A, B>) => Refinement<A, B>
+  /**
+   * @since 2.0.0
+   */
   <A, B extends A, C extends B>(ab: Refinement<A, B>, bc: Refinement<B, C>): Refinement<A, C>
+  /**
+   * @since 2.0.0
+   */
   <A, B extends A>(ab: Refinement<A, B>, bc: Predicate<NoInfer<B>>): Refinement<A, B>
 } = dual(
   2,
@@ -733,6 +951,17 @@ export const productMany = <A>(
  * @since 2.0.0
  */
 export const tuple: {
+  /**
+   * Similar to `Promise.all` but operates on `Predicate`s.
+   *
+   * ```
+   * [Refinement<A, B>, Refinement<C, D>, ...] -> Refinement<[A, C, ...], [B, D, ...]>
+   * [Predicate<A>, Predicate<B>, ...] -> Predicate<[A, B, ...]>
+   * [Refinement<A, B>, Predicate<C>, ...] -> Refinement<[A, C, ...], [B, C, ...]>
+   * ```
+   *
+   * @since 2.0.0
+   */
   <T extends ReadonlyArray<Predicate.Any>>(
     ...elements: T
   ): [Extract<T[number], Refinement.Any>] extends [never] ? Predicate<{ readonly [I in keyof T]: Predicate.In<T[I]> }>
@@ -752,6 +981,15 @@ export const tuple: {
  * @since 2.0.0
  */
 export const struct: {
+  /**
+   * ```
+   * { ab: Refinement<A, B>; cd: Refinement<C, D>, ... } -> Refinement<{ ab: A; cd: C; ... }, { ab: B; cd: D; ... }>
+   * { a: Predicate<A, B>; b: Predicate<B>, ... } -> Predicate<{ a: A; b: B; ... }>
+   * { ab: Refinement<A, B>; c: Predicate<C>, ... } -> Refinement<{ ab: A; c: C; ... }, { ab: B; c: С; ... }>
+   * ```
+   *
+   * @since 2.0.0
+   */
   <R extends Record<string, Predicate.Any>>(
     fields: R
   ): [Extract<R[keyof R], Refinement.Any>] extends [never] ?
@@ -810,9 +1048,81 @@ export const not = <A>(self: Predicate<A>): Predicate<A> => (a) => !self(a)
  * @since 2.0.0
  */
 export const or: {
+  /**
+   * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
+   *
+   * assert.deepStrictEqual(nonZero(-1), true)
+   * assert.deepStrictEqual(nonZero(0), false)
+   * assert.deepStrictEqual(nonZero(1), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A, C extends A>(that: Refinement<A, C>): <B extends A>(self: Refinement<A, B>) => Refinement<A, B | C>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
+   *
+   * assert.deepStrictEqual(nonZero(-1), true)
+   * assert.deepStrictEqual(nonZero(0), false)
+   * assert.deepStrictEqual(nonZero(1), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A, B extends A, C extends A>(self: Refinement<A, B>, that: Refinement<A, C>): Refinement<A, B | C>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
+   *
+   * assert.deepStrictEqual(nonZero(-1), true)
+   * assert.deepStrictEqual(nonZero(0), false)
+   * assert.deepStrictEqual(nonZero(1), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate, Number } from "effect"
+   *
+   * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
+   *
+   * assert.deepStrictEqual(nonZero(-1), true)
+   * assert.deepStrictEqual(nonZero(0), false)
+   * assert.deepStrictEqual(nonZero(1), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) || that(a))
 
@@ -838,9 +1148,93 @@ export const or: {
  * @since 2.0.0
  */
 export const and: {
+  /**
+   * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * const minLength = (n: number) => (s: string) => s.length >= n
+   * const maxLength = (n: number) => (s: string) => s.length <= n
+   *
+   * const length = (n: number) => Predicate.and(minLength(n), maxLength(n))
+   *
+   * assert.deepStrictEqual(length(2)("aa"), true)
+   * assert.deepStrictEqual(length(2)("a"), false)
+   * assert.deepStrictEqual(length(2)("aaa"), false)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A, C extends A>(that: Refinement<A, C>): <B extends A>(self: Refinement<A, B>) => Refinement<A, B & C>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * const minLength = (n: number) => (s: string) => s.length >= n
+   * const maxLength = (n: number) => (s: string) => s.length <= n
+   *
+   * const length = (n: number) => Predicate.and(minLength(n), maxLength(n))
+   *
+   * assert.deepStrictEqual(length(2)("aa"), true)
+   * assert.deepStrictEqual(length(2)("a"), false)
+   * assert.deepStrictEqual(length(2)("aaa"), false)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A, B extends A, C extends A>(self: Refinement<A, B>, that: Refinement<A, C>): Refinement<A, B & C>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * const minLength = (n: number) => (s: string) => s.length >= n
+   * const maxLength = (n: number) => (s: string) => s.length <= n
+   *
+   * const length = (n: number) => Predicate.and(minLength(n), maxLength(n))
+   *
+   * assert.deepStrictEqual(length(2)("aa"), true)
+   * assert.deepStrictEqual(length(2)("a"), false)
+   * assert.deepStrictEqual(length(2)("aaa"), false)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
+   *
+   * @param self - A predicate.
+   * @param that - A predicate.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * const minLength = (n: number) => (s: string) => s.length >= n
+   * const maxLength = (n: number) => (s: string) => s.length <= n
+   *
+   * const length = (n: number) => Predicate.and(minLength(n), maxLength(n))
+   *
+   * assert.deepStrictEqual(length(2)("aa"), true)
+   * assert.deepStrictEqual(length(2)("a"), false)
+   * assert.deepStrictEqual(length(2)("aaa"), false)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) && that(a))
 
@@ -849,7 +1243,15 @@ export const and: {
  * @since 2.0.0
  */
 export const xor: {
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) !== that(a))
 
@@ -858,7 +1260,15 @@ export const xor: {
  * @since 2.0.0
  */
 export const eqv: {
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) === that(a))
 
@@ -907,7 +1317,95 @@ export const eqv: {
  * @since 2.0.0
  */
 export const implies: {
+  /**
+   * Represents the logical implication combinator for predicates. In formal
+   * logic, the implication operator `->` denotes that if the first proposition
+   * (antecedent) is true, then the second proposition (consequent) must also be
+   * true. In simpler terms, `p implies q` can be interpreted as "if p then q". If
+   * the first predicate holds, then the second predicate must hold
+   * for the given context.
+   *
+   * In practical terms within TypeScript, `p implies q` is equivalent to `!p || (p && q)`.
+   *
+   * Note that if the antecedent is `false`, the result is `true` by default
+   * because the outcome of the consequent cannot be determined.
+   *
+   * This function is useful in situations where you need to enforce rules or
+   * constraints that are contingent on certain conditions.
+   * It proves especially helpful in defining property tests.
+   *
+   * The example below illustrates the transitive property of order using the
+   * `implies` function. In simple terms, if `a <= b` and `b <= c`, then `a <= c`
+   * must be true.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * type Triple = {
+   *   readonly a: number
+   *   readonly b: number
+   *   readonly c: number
+   * }
+   *
+   * const transitivity = Predicate.implies(
+   *   // antecedent
+   *   (input: Triple) => input.a <= input.b && input.b <= input.c,
+   *   // consequent
+   *   (input: Triple) => input.a <= input.c
+   * )
+   *
+   * assert.equal(transitivity({ a: 1, b: 2, c: 3 }), true)
+   * // antecedent is `false`, so the result is `true`
+   * assert.equal(transitivity({ a: 1, b: 0, c: 0 }), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(consequent: Predicate<A>): (antecedent: Predicate<A>) => Predicate<A>
+  /**
+   * Represents the logical implication combinator for predicates. In formal
+   * logic, the implication operator `->` denotes that if the first proposition
+   * (antecedent) is true, then the second proposition (consequent) must also be
+   * true. In simpler terms, `p implies q` can be interpreted as "if p then q". If
+   * the first predicate holds, then the second predicate must hold
+   * for the given context.
+   *
+   * In practical terms within TypeScript, `p implies q` is equivalent to `!p || (p && q)`.
+   *
+   * Note that if the antecedent is `false`, the result is `true` by default
+   * because the outcome of the consequent cannot be determined.
+   *
+   * This function is useful in situations where you need to enforce rules or
+   * constraints that are contingent on certain conditions.
+   * It proves especially helpful in defining property tests.
+   *
+   * The example below illustrates the transitive property of order using the
+   * `implies` function. In simple terms, if `a <= b` and `b <= c`, then `a <= c`
+   * must be true.
+   *
+   * @example
+   * import { Predicate } from "effect"
+   *
+   * type Triple = {
+   *   readonly a: number
+   *   readonly b: number
+   *   readonly c: number
+   * }
+   *
+   * const transitivity = Predicate.implies(
+   *   // antecedent
+   *   (input: Triple) => input.a <= input.b && input.b <= input.c,
+   *   // consequent
+   *   (input: Triple) => input.a <= input.c
+   * )
+   *
+   * assert.equal(transitivity({ a: 1, b: 2, c: 3 }), true)
+   * // antecedent is `false`, so the result is `true`
+   * assert.equal(transitivity({ a: 1, b: 0, c: 0 }), true)
+   *
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(antecedent: Predicate<A>, consequent: Predicate<A>): Predicate<A>
 } = dual(
   2,
@@ -919,7 +1417,15 @@ export const implies: {
  * @since 2.0.0
  */
 export const nor: {
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(
   2,
@@ -931,7 +1437,15 @@ export const nor: {
  * @since 2.0.0
  */
 export const nand: {
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
+  /**
+   * @category combinators
+   * @since 2.0.0
+   */
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(
   2,

package/src/PubSub.ts

@@ -155,7 +155,21 @@ export const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<void> = intern
  * @category utils
  */
 export const publish: {
+  /**
+   * Publishes a message to the `PubSub`, returning whether the message was published
+   * to the `PubSub`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: PubSub<A>) => Effect.Effect<boolean>
+  /**
+   * Publishes a message to the `PubSub`, returning whether the message was published
+   * to the `PubSub`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: PubSub<A>, value: A): Effect.Effect<boolean>
 } = internal.publish
 
@@ -167,7 +181,21 @@ export const publish: {
  * @category utils
  */
 export const publishAll: {
+  /**
+   * Publishes all of the specified messages to the `PubSub`, returning whether they
+   * were published to the `PubSub`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(elements: Iterable<A>): (self: PubSub<A>) => Effect.Effect<boolean>
+  /**
+   * Publishes all of the specified messages to the `PubSub`, returning whether they
+   * were published to the `PubSub`.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<boolean>
 } = internal.publishAll