effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/Predicate.ts

@@ -29,12 +29,12 @@ import type { TupleOf, TupleOfAtLeast } from "./Types.ts"
  *
  * **Example** (Defining a predicate)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isPositive: Predicate.Predicate<number> = (n) => n > 0
  *
- * console.log(isPositive(1))
+ * isPositive(1) // => true
  * ```
  *
  * @see {@link Refinement}
@@ -62,15 +62,18 @@ export interface Predicate<in A> {
  *
  * **Example** (Type-level usage)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * type P = Predicate.Predicate<number>
  * type TL = Predicate.PredicateTypeLambda
+ *
+ * const witness: P = (value) => value > 0
+ * witness(1) // => true
  * ```
  *
  * @see {@link Predicate}
- * @category type lambdas
+ * @category utility types
  * @since 2.0.0
  */
 export interface PredicateTypeLambda extends TypeLambda {
@@ -93,14 +96,14 @@ export interface PredicateTypeLambda extends TypeLambda {
  *
  * **Example** (Narrowing unknown values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isString: Predicate.Refinement<unknown, string> = (u): u is string => typeof u === "string"
  *
  * const data: unknown = "hello"
  * if (isString(data)) {
- *   console.log(data.toUpperCase())
+ *   data.toUpperCase() // => "HELLO"
  * }
  * ```
  *
@@ -129,11 +132,13 @@ export interface Refinement<in A, out B extends A> {
  *
  * **Example** (Extracting predicate input)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * type IsString = Predicate.Predicate<string>
  * type Input = Predicate.Predicate.In<IsString>
+ *
+ * const input: Input = "value"
  * ```
  *
  * @see {@link Predicate}
@@ -156,11 +161,13 @@ export declare namespace Predicate {
    *
    * **Example** (Inferring the input type)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * type P = Predicate.Predicate<number>
    * type Input = Predicate.Predicate.In<P>
+   *
+   * const input: Input = 1
    * ```
    *
    * @see {@link Predicate.Any}
@@ -183,10 +190,13 @@ export declare namespace Predicate {
    *
    * **Example** (Using generic constraints)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * type AnyPredicate = Predicate.Predicate.Any
+   *
+   * const witness: AnyPredicate = () => true
+   * witness("value") // => true
    * ```
    *
    * @see {@link Predicate.In}
@@ -211,12 +221,14 @@ export declare namespace Predicate {
  *
  * **Example** (Extracting refinement types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * type IsString = Predicate.Refinement<unknown, string>
  * type Input = Predicate.Refinement.In<IsString>
  * type Output = Predicate.Refinement.Out<IsString>
+ *
+ * const output: Output = "value"
  * ```
  *
  * @see {@link Refinement}
@@ -238,11 +250,13 @@ export declare namespace Refinement {
    *
    * **Example** (Inferring the input type)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * type R = Predicate.Refinement<unknown, string>
    * type Input = Predicate.Refinement.In<R>
+   *
+   * const input: Input = "value"
    * ```
    *
    * @see {@link Refinement.Out}
@@ -267,11 +281,13 @@ export declare namespace Refinement {
    *
    * **Example** (Inferring the output type)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * type R = Predicate.Refinement<unknown, string>
    * type Output = Predicate.Refinement.Out<R>
+   *
+   * const output: Output = "value"
    * ```
    *
    * @see {@link Refinement.In}
@@ -293,10 +309,13 @@ export declare namespace Refinement {
    *
    * **Example** (Using generic constraints)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * type AnyRefinement = Predicate.Refinement.Any
+   *
+   * const witness: AnyRefinement = (_): _ is string => true
+   * witness("value") // => true
    * ```
    *
    * @see {@link Refinement.In}
@@ -322,14 +341,14 @@ export declare namespace Refinement {
  *
  * **Example** (Checking string length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isLongerThan2 = Predicate.mapInput((s: string) => s.length)(
  *   (n: number) => n > 2
  * )
  *
- * console.log(isLongerThan2("hello"))
+ * isLongerThan2("hello") // => true
  * ```
  *
  * @see {@link Predicate}
@@ -354,14 +373,14 @@ export const mapInput: {
    *
    * **Example** (Checking string length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isLongerThan2 = Predicate.mapInput((s: string) => s.length)(
    *   (n: number) => n > 2
    * )
    *
-   * console.log(isLongerThan2("hello"))
+   * isLongerThan2("hello") // => true
    * ```
    *
    * @see {@link Predicate}
@@ -386,14 +405,14 @@ export const mapInput: {
    *
    * **Example** (Checking string length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isLongerThan2 = Predicate.mapInput((s: string) => s.length)(
    *   (n: number) => n > 2
    * )
    *
-   * console.log(isLongerThan2("hello"))
+   * isLongerThan2("hello") // => true
    * ```
    *
    * @see {@link Predicate}
@@ -420,12 +439,12 @@ export const mapInput: {
  *
  * **Example** (Checking exact length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isPair = Predicate.isTupleOf(2)
  *
- * console.log(isPair([1, 2]))
+ * isPair([1, 2]) // => true
  * ```
  *
  * @see {@link isTupleOfAtLeast}
@@ -449,12 +468,12 @@ export const isTupleOf: {
    *
    * **Example** (Checking exact length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isPair = Predicate.isTupleOf(2)
    *
-   * console.log(isPair([1, 2]))
+   * isPair([1, 2]) // => true
    * ```
    *
    * @see {@link isTupleOfAtLeast}
@@ -478,12 +497,12 @@ export const isTupleOf: {
    *
    * **Example** (Checking exact length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isPair = Predicate.isTupleOf(2)
    *
-   * console.log(isPair([1, 2]))
+   * isPair([1, 2]) // => true
    * ```
    *
    * @see {@link isTupleOfAtLeast}
@@ -509,12 +528,12 @@ export const isTupleOf: {
  *
  * **Example** (Checking minimum length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const hasAtLeast2 = Predicate.isTupleOfAtLeast(2)
  *
- * console.log(hasAtLeast2([1, 2, 3]))
+ * hasAtLeast2([1, 2, 3]) // => true
  * ```
  *
  * @see {@link isTupleOf}
@@ -538,12 +557,12 @@ export const isTupleOfAtLeast: {
    *
    * **Example** (Checking minimum length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAtLeast2 = Predicate.isTupleOfAtLeast(2)
    *
-   * console.log(hasAtLeast2([1, 2, 3]))
+   * hasAtLeast2([1, 2, 3]) // => true
    * ```
    *
    * @see {@link isTupleOf}
@@ -567,12 +586,12 @@ export const isTupleOfAtLeast: {
    *
    * **Example** (Checking minimum length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAtLeast2 = Predicate.isTupleOfAtLeast(2)
    *
-   * console.log(hasAtLeast2([1, 2, 3]))
+   * hasAtLeast2([1, 2, 3]) // => true
    * ```
    *
    * @see {@link isTupleOf}
@@ -598,18 +617,16 @@ export const isTupleOfAtLeast: {
  *
  * **Example** (Filtering truthy values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const values = [0, 1, "", "ok", false]
- * const truthy = values.filter(Predicate.isTruthy)
- *
- * console.log(truthy)
+ * const truthy = values.filter(Predicate.isTruthy) // => [1, "ok"]
  * ```
  *
  * @see {@link isNullish}
  * @see {@link isNotNullish}
- * @category guards
+ * @category predicates
  * @since 2.0.0
  */
 export function isTruthy(input: unknown): boolean {
@@ -629,13 +646,13 @@ export function isTruthy(input: unknown): boolean {
  *
  * **Example** (Guarding a Set)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = new Set([1, 2])
  *
  * if (Predicate.isSet(data)) {
- *   console.log(data.size)
+ *   data.size // => 2
  * }
  * ```
  *
@@ -661,13 +678,13 @@ export function isSet(input: unknown): input is Set<unknown> {
  *
  * **Example** (Guarding a Map)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = new Map([["a", 1]])
  *
  * if (Predicate.isMap(data)) {
- *   console.log(data.size)
+ *   data.size // => 1
  * }
  * ```
  *
@@ -694,13 +711,13 @@ export function isMap(input: unknown): input is Map<unknown, unknown> {
  *
  * **Example** (Guarding strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = "hi"
  *
  * if (Predicate.isString(data)) {
- *   console.log(data.toUpperCase())
+ *   data.toUpperCase() // => "HI"
  * }
  * ```
  *
@@ -728,13 +745,13 @@ export function isString(input: unknown): input is string {
  *
  * **Example** (Guarding numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = 42
  *
  * if (Predicate.isNumber(data)) {
- *   console.log(data + 1)
+ *   data + 1 // => 43
  * }
  * ```
  *
@@ -761,13 +778,13 @@ export function isNumber(input: unknown): input is number {
  *
  * **Example** (Guarding booleans)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = true
  *
  * if (Predicate.isBoolean(data)) {
- *   console.log(data ? "yes" : "no")
+ *   data ? "yes" : "no" // => "yes"
  * }
  * ```
  *
@@ -794,13 +811,13 @@ export function isBoolean(input: unknown): input is boolean {
  *
  * **Example** (Guarding bigints)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = 1n
  *
  * if (Predicate.isBigInt(data)) {
- *   console.log(data + 2n)
+ *   data + 2n // => 3n
  * }
  * ```
  *
@@ -826,13 +843,13 @@ export function isBigInt(input: unknown): input is bigint {
  *
  * **Example** (Guarding symbols)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = Symbol.for("id")
  *
  * if (Predicate.isSymbol(data)) {
- *   console.log(data.description)
+ *   data.description // => "id"
  * }
  * ```
  *
@@ -858,14 +875,14 @@ export function isSymbol(input: unknown): input is symbol {
  *
  * **Example** (Guarding property keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const key: unknown = "name"
  * const obj: Record<PropertyKey, unknown> = { name: "Ada" }
  *
  * if (Predicate.isPropertyKey(key) && key in obj) {
- *   console.log(obj[key])
+ *   obj[key] // => "Ada"
  * }
  * ```
  *
@@ -893,13 +910,13 @@ export function isPropertyKey(u: unknown): u is PropertyKey {
  *
  * **Example** (Guarding functions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = () => 1
  *
  * if (Predicate.isFunction(data)) {
- *   console.log(data())
+ *   data() // => 1
  * }
  * ```
  *
@@ -925,12 +942,12 @@ export function isFunction(input: unknown): input is Function {
  *
  * **Example** (Guarding undefined values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = undefined
  *
- * console.log(Predicate.isUndefined(data))
+ * Predicate.isUndefined(data) // => true
  * ```
  *
  * @see {@link isNotUndefined}
@@ -956,13 +973,11 @@ export function isUndefined(input: unknown): input is undefined {
  *
  * **Example** (Filtering undefined values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const values = [1, undefined, 2]
- * const defined = values.filter(Predicate.isNotUndefined)
- *
- * console.log(defined)
+ * const defined = values.filter(Predicate.isNotUndefined) // => [1, 2]
  * ```
  *
  * @see {@link isUndefined}
@@ -987,12 +1002,12 @@ export function isNotUndefined<A>(input: A): input is Exclude<A, undefined> {
  *
  * **Example** (Guarding null values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = null
  *
- * console.log(Predicate.isNull(data))
+ * Predicate.isNull(data) // => true
  * ```
  *
  * @see {@link isNotNull}
@@ -1018,13 +1033,11 @@ export function isNull(input: unknown): input is null {
  *
  * **Example** (Filtering null values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const values = [1, null, 2]
- * const nonNull = values.filter(Predicate.isNotNull)
- *
- * console.log(nonNull)
+ * const nonNull = values.filter(Predicate.isNotNull) // => [1, 2]
  * ```
  *
  * @see {@link isNull}
@@ -1049,13 +1062,11 @@ export function isNotNull<A>(input: A): input is Exclude<A, null> {
  *
  * **Example** (Guarding nullish values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const values = [0, null, "", undefined]
- * const nullish = values.filter(Predicate.isNullish)
- *
- * console.log(nullish)
+ * const nullish = values.filter(Predicate.isNullish) // => [null, undefined]
  * ```
  *
  * @see {@link isNotNullish}
@@ -1082,13 +1093,11 @@ export function isNullish<A>(input: A): input is A & (null | undefined) {
  *
  * **Example** (Filtering non-nullish values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const values = [0, null, "", undefined]
- * const present = values.filter(Predicate.isNotNullish)
- *
- * console.log(present)
+ * const present = values.filter(Predicate.isNotNullish) // => [0, ""]
  * ```
  *
  * @see {@link isNullish}
@@ -1110,10 +1119,10 @@ export function isNotNullish<A>(input: A): input is NonNullable<A> {
  *
  * **Example** (Matching no values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isNever("anything"))
+ * Predicate.isNever("anything") // => false
  * ```
  *
  * @see {@link isUnknown}
@@ -1133,10 +1142,10 @@ export function isNever(_: unknown): _ is never {
  *
  * **Example** (Matching every value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isUnknown(123))
+ * Predicate.isUnknown(123) // => true
  * ```
  *
  * @see {@link isNever}
@@ -1161,10 +1170,10 @@ export function isUnknown(_: unknown): _ is unknown {
  *
  * **Example** (Checking objects or arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isObjectOrArray([]))
+ * Predicate.isObjectOrArray([]) // => true
  * ```
  *
  * @see {@link isObject}
@@ -1192,11 +1201,11 @@ export function isObjectOrArray(input: unknown): input is { [x: PropertyKey]: un
  *
  * **Example** (Guarding objects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isObject({ a: 1 }))
- * console.log(Predicate.isObject([1, 2]))
+ * Predicate.isObject({ a: 1 }) // => true
+ * Predicate.isObject([1, 2]) // => false
  * ```
  *
  * @see {@link isObjectOrArray}
@@ -1225,12 +1234,12 @@ export function isObject(input: unknown): input is { [x: PropertyKey]: unknown }
  *
  * **Example** (Checking readonly objects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = { a: 1 }
  *
- * console.log(Predicate.isReadonlyObject(data))
+ * Predicate.isReadonlyObject(data) // => true
  * ```
  *
  * @see {@link isObject}
@@ -1255,11 +1264,11 @@ export function isReadonlyObject(input: unknown): input is { readonly [x: Proper
  *
  * **Example** (Checking object keywords)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isObjectKeyword(() => 1))
- * console.log(Predicate.isObjectKeyword(null))
+ * Predicate.isObjectKeyword(() => 1) // => true
+ * Predicate.isObjectKeyword(null) // => false
  * ```
  *
  * @see {@link isObject}
@@ -1286,14 +1295,14 @@ export function isObjectKeyword(input: unknown): input is object {
  *
  * **Example** (Guarding object properties)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const hasName = Predicate.hasProperty("name")
  * const data: unknown = { name: "Ada" }
  *
  * if (hasName(data)) {
- *   console.log(data.name)
+ *   data.name // => "Ada"
  * }
  * ```
  *
@@ -1318,14 +1327,14 @@ export const hasProperty: {
    *
    * **Example** (Guarding object properties)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasName = Predicate.hasProperty("name")
    * const data: unknown = { name: "Ada" }
    *
    * if (hasName(data)) {
-   *   console.log(data.name)
+   *   data.name // => "Ada"
    * }
    * ```
    *
@@ -1350,14 +1359,14 @@ export const hasProperty: {
    *
    * **Example** (Guarding object properties)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasName = Predicate.hasProperty("name")
    * const data: unknown = { name: "Ada" }
    *
    * if (hasName(data)) {
-   *   console.log(data.name)
+   *   data.name // => "Ada"
    * }
    * ```
    *
@@ -1387,12 +1396,12 @@ export const hasProperty: {
  *
  * **Example** (Guarding tagged values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isOk = Predicate.isTagged("Ok")
  *
- * console.log(isOk({ _tag: "Ok", value: 1 }))
+ * isOk({ _tag: "Ok", value: 1 }) // => true
  * ```
  *
  * @see {@link hasProperty}
@@ -1414,12 +1423,12 @@ export const isTagged: {
    *
    * **Example** (Guarding tagged values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isOk = Predicate.isTagged("Ok")
    *
-   * console.log(isOk({ _tag: "Ok", value: 1 }))
+   * isOk({ _tag: "Ok", value: 1 }) // => true
    * ```
    *
    * @see {@link hasProperty}
@@ -1441,12 +1450,12 @@ export const isTagged: {
    *
    * **Example** (Guarding tagged values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isOk = Predicate.isTagged("Ok")
    *
-   * console.log(isOk({ _tag: "Ok", value: 1 }))
+   * isOk({ _tag: "Ok", value: 1 }) // => true
    * ```
    *
    * @see {@link hasProperty}
@@ -1472,12 +1481,12 @@ export const isTagged: {
  *
  * **Example** (Guarding errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = new Error("boom")
  *
- * console.log(Predicate.isError(data))
+ * Predicate.isError(data) // => true
  * ```
  *
  * @see {@link isUnknown}
@@ -1501,12 +1510,12 @@ export function isError(input: unknown): input is Error {
  *
  * **Example** (Guarding Uint8Array values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = new Uint8Array([1, 2])
  *
- * console.log(Predicate.isUint8Array(data))
+ * Predicate.isUint8Array(data) // => true
  * ```
  *
  * @see {@link isIterable}
@@ -1531,12 +1540,12 @@ export function isUint8Array(input: unknown): input is Uint8Array {
  *
  * **Example** (Guarding Date values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = new Date()
  *
- * console.log(Predicate.isDate(data))
+ * Predicate.isDate(data) // => true
  * ```
  *
  * @see {@link isRegExp}
@@ -1560,12 +1569,12 @@ export function isDate(input: unknown): input is Date {
  *
  * **Example** (Guarding iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = [1, 2, 3]
  *
- * console.log(Predicate.isIterable(data))
+ * Predicate.isIterable(data) // => true
  * ```
  *
  * @see {@link isSet}
@@ -1590,12 +1599,12 @@ export function isIterable(input: unknown): input is Iterable<unknown> {
  *
  * **Example** (Guarding promises)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = Promise.resolve(1)
  *
- * console.log(Predicate.isPromise(data))
+ * Predicate.isPromise(data) // => true
  * ```
  *
  * @see {@link isPromiseLike}
@@ -1620,12 +1629,12 @@ export function isPromise(input: unknown): input is Promise<unknown> {
  *
  * **Example** (Guarding promise-like values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = { then: () => {} }
  *
- * console.log(Predicate.isPromiseLike(data))
+ * Predicate.isPromiseLike(data) // => true
  * ```
  *
  * @see {@link isPromise}
@@ -1649,12 +1658,12 @@ export function isPromiseLike(input: unknown): input is PromiseLike<unknown> {
  *
  * **Example** (Guarding RegExp values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const data: unknown = /abc/
  *
- * console.log(Predicate.isRegExp(data))
+ * Predicate.isRegExp(data) // => true
  * ```
  *
  * @see {@link isDate}
@@ -1680,7 +1689,7 @@ export function isRegExp(input: unknown): input is RegExp {
  *
  * **Example** (Composing refinements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isNumber: Predicate.Refinement<unknown, number> = (u): u is number => typeof u === "number"
@@ -1688,7 +1697,7 @@ export function isRegExp(input: unknown): input is RegExp {
  *
  * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
  *
- * console.log(isIntegerNumber(1))
+ * isIntegerNumber(1) // => true
  * ```
  *
  * @see {@link and}
@@ -1712,7 +1721,7 @@ export const compose: {
    *
    * **Example** (Composing refinements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isNumber: Predicate.Refinement<unknown, number> = (u): u is number => typeof u === "number"
@@ -1720,7 +1729,7 @@ export const compose: {
    *
    * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
    *
-   * console.log(isIntegerNumber(1))
+   * isIntegerNumber(1) // => true
    * ```
    *
    * @see {@link and}
@@ -1744,7 +1753,7 @@ export const compose: {
    *
    * **Example** (Composing refinements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isNumber: Predicate.Refinement<unknown, number> = (u): u is number => typeof u === "number"
@@ -1752,7 +1761,7 @@ export const compose: {
    *
    * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
    *
-   * console.log(isIntegerNumber(1))
+   * isIntegerNumber(1) // => true
    * ```
    *
    * @see {@link and}
@@ -1776,7 +1785,7 @@ export const compose: {
    *
    * **Example** (Composing refinements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isNumber: Predicate.Refinement<unknown, number> = (u): u is number => typeof u === "number"
@@ -1784,7 +1793,7 @@ export const compose: {
    *
    * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
    *
-   * console.log(isIntegerNumber(1))
+   * isIntegerNumber(1) // => true
    * ```
    *
    * @see {@link and}
@@ -1808,7 +1817,7 @@ export const compose: {
    *
    * **Example** (Composing refinements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isNumber: Predicate.Refinement<unknown, number> = (u): u is number => typeof u === "number"
@@ -1816,7 +1825,7 @@ export const compose: {
    *
    * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
    *
-   * console.log(isIntegerNumber(1))
+   * isIntegerNumber(1) // => true
    * ```
    *
    * @see {@link and}
@@ -1846,12 +1855,12 @@ export const compose: {
  *
  * **Example** (Checking tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const tupleCheck = Predicate.Tuple([(n: number) => n > 0, Predicate.isString])
  *
- * console.log(tupleCheck([1, "ok"]))
+ * tupleCheck([1, "ok"]) // => true
  * ```
  *
  * @see {@link Struct}
@@ -1892,7 +1901,7 @@ export function Tuple<const T extends ReadonlyArray<Predicate.Any>>(
  *
  * **Example** (Checking structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const userCheck = Predicate.Struct({
@@ -1900,7 +1909,7 @@ export function Tuple<const T extends ReadonlyArray<Predicate.Any>>(
  *   name: Predicate.isString
  * })
  *
- * console.log(userCheck({ id: 1, name: "Ada" }))
+ * userCheck({ id: 1, name: "Ada" }) // => true
  * ```
  *
  * @see {@link Tuple}
@@ -1940,12 +1949,12 @@ export function Struct<R extends Record<string, Predicate.Any>>(
  *
  * **Example** (Negating a predicate)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isNotString = Predicate.not(Predicate.isString)
  *
- * console.log(isNotString(1))
+ * isNotString(1) // => true
  * ```
  *
  * @see {@link and}
@@ -1973,12 +1982,12 @@ export function not<A>(self: Predicate<A>): Predicate<A> {
  *
  * **Example** (Checking either condition)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
  *
- * console.log(isStringOrNumber("a"))
+ * isStringOrNumber("a") // => true
  * ```
  *
  * @see {@link and}
@@ -2002,12 +2011,12 @@ export const or: {
    *
    * **Example** (Checking either condition)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(isStringOrNumber("a"))
+   * isStringOrNumber("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2031,12 +2040,12 @@ export const or: {
    *
    * **Example** (Checking either condition)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(isStringOrNumber("a"))
+   * isStringOrNumber("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2060,12 +2069,12 @@ export const or: {
    *
    * **Example** (Checking either condition)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(isStringOrNumber("a"))
+   * isStringOrNumber("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2089,12 +2098,12 @@ export const or: {
    *
    * **Example** (Checking either condition)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(isStringOrNumber("a"))
+   * isStringOrNumber("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2121,7 +2130,7 @@ export const or: {
  *
  * **Example** (Checking both conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const hasAAndB = Predicate.and(
@@ -2134,6 +2143,8 @@ export const or: {
  *   // input has both properties at this point
  *   const a = input.a
  *   const b = input.b
+ *
+ *   const values = [a, b] // => [1, "ok"]
  * }
  * ```
  *
@@ -2159,7 +2170,7 @@ export const and: {
    *
    * **Example** (Checking both conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAAndB = Predicate.and(
@@ -2172,6 +2183,8 @@ export const and: {
    *   // input has both properties at this point
    *   const a = input.a
    *   const b = input.b
+   *
+   *   const values = [a, b] // => [1, "ok"]
    * }
    * ```
    *
@@ -2197,7 +2210,7 @@ export const and: {
    *
    * **Example** (Checking both conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAAndB = Predicate.and(
@@ -2210,6 +2223,8 @@ export const and: {
    *   // input has both properties at this point
    *   const a = input.a
    *   const b = input.b
+   *
+   *   const values = [a, b] // => [1, "ok"]
    * }
    * ```
    *
@@ -2235,7 +2250,7 @@ export const and: {
    *
    * **Example** (Checking both conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAAndB = Predicate.and(
@@ -2248,6 +2263,8 @@ export const and: {
    *   // input has both properties at this point
    *   const a = input.a
    *   const b = input.b
+   *
+   *   const values = [a, b] // => [1, "ok"]
    * }
    * ```
    *
@@ -2273,7 +2290,7 @@ export const and: {
    *
    * **Example** (Checking both conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const hasAAndB = Predicate.and(
@@ -2286,6 +2303,8 @@ export const and: {
    *   // input has both properties at this point
    *   const a = input.a
    *   const b = input.b
+   *
+   *   const values = [a, b] // => [1, "ok"]
    * }
    * ```
    *
@@ -2310,14 +2329,14 @@ export const and: {
  *
  * **Example** (Checking exclusive-or conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isEven = (n: number) => n % 2 === 0
  * const isPositive = (n: number) => n > 0
  * const either = Predicate.xor(isEven, isPositive)
  *
- * console.log(either(-2))
+ * either(-2) // => true
  * ```
  *
  * @see {@link or}
@@ -2339,14 +2358,14 @@ export const xor: {
    *
    * **Example** (Checking exclusive-or conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isEven = (n: number) => n % 2 === 0
    * const isPositive = (n: number) => n > 0
    * const either = Predicate.xor(isEven, isPositive)
    *
-   * console.log(either(-2))
+   * either(-2) // => true
    * ```
    *
    * @see {@link or}
@@ -2368,14 +2387,14 @@ export const xor: {
    *
    * **Example** (Checking exclusive-or conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isEven = (n: number) => n % 2 === 0
    * const isPositive = (n: number) => n > 0
    * const either = Predicate.xor(isEven, isPositive)
    *
-   * console.log(either(-2))
+   * either(-2) // => true
    * ```
    *
    * @see {@link or}
@@ -2399,13 +2418,13 @@ export const xor: {
  *
  * **Example** (Defining equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isEven = (n: number) => n % 2 === 0
  * const same = Predicate.eqv(isEven, isEven)
  *
- * console.log(same(3))
+ * same(3) // => true
  * ```
  *
  * @see {@link xor}
@@ -2426,13 +2445,13 @@ export const eqv: {
    *
    * **Example** (Defining equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isEven = (n: number) => n % 2 === 0
    * const same = Predicate.eqv(isEven, isEven)
    *
-   * console.log(same(3))
+   * same(3) // => true
    * ```
    *
    * @see {@link xor}
@@ -2453,13 +2472,13 @@ export const eqv: {
    *
    * **Example** (Defining equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isEven = (n: number) => n % 2 === 0
    * const same = Predicate.eqv(isEven, isEven)
    *
-   * console.log(same(3))
+   * same(3) // => true
    * ```
    *
    * @see {@link xor}
@@ -2484,14 +2503,14 @@ export const eqv: {
  *
  * **Example** (Checking implication)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const isAdult = (age: number) => age >= 18
  * const canVote = (age: number) => age >= 18
  * const implies = Predicate.implies(isAdult, canVote)
  *
- * console.log(implies(16))
+ * implies(16) // => true
  * ```
  *
  * @see {@link and}
@@ -2515,14 +2534,14 @@ export const implies: {
    *
    * **Example** (Checking implication)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isAdult = (age: number) => age >= 18
    * const canVote = (age: number) => age >= 18
    * const implies = Predicate.implies(isAdult, canVote)
    *
-   * console.log(implies(16))
+   * implies(16) // => true
    * ```
    *
    * @see {@link and}
@@ -2546,14 +2565,14 @@ export const implies: {
    *
    * **Example** (Checking implication)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const isAdult = (age: number) => age >= 18
    * const canVote = (age: number) => age >= 18
    * const implies = Predicate.implies(isAdult, canVote)
    *
-   * console.log(implies(16))
+   * implies(16) // => true
    * ```
    *
    * @see {@link and}
@@ -2580,12 +2599,12 @@ export const implies: {
  *
  * **Example** (Checking NOR conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
  *
- * console.log(neither(true))
+ * neither(true) // => true
  * ```
  *
  * @see {@link or}
@@ -2607,12 +2626,12 @@ export const nor: {
    *
    * **Example** (Checking NOR conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(neither(true))
+   * neither(true) // => true
    * ```
    *
    * @see {@link or}
@@ -2634,12 +2653,12 @@ export const nor: {
    *
    * **Example** (Checking NOR conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(neither(true))
+   * neither(true) // => true
    * ```
    *
    * @see {@link or}
@@ -2666,12 +2685,12 @@ export const nor: {
  *
  * **Example** (Checking NAND conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
  *
- * console.log(notBoth("a"))
+ * notBoth("a") // => true
  * ```
  *
  * @see {@link and}
@@ -2693,12 +2712,12 @@ export const nand: {
    *
    * **Example** (Checking NAND conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(notBoth("a"))
+   * notBoth("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2720,12 +2739,12 @@ export const nand: {
    *
    * **Example** (Checking NAND conditions)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Predicate } from "effect"
    *
    * const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
    *
-   * console.log(notBoth("a"))
+   * notBoth("a") // => true
    * ```
    *
    * @see {@link and}
@@ -2753,17 +2772,17 @@ export const nand: {
  *
  * **Example** (Checking all predicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const allChecks = Predicate.every([Predicate.isNumber, (n: number) => n > 0])
  *
- * console.log(allChecks(2))
+ * allChecks(2) // => true
  * ```
  *
  * @see {@link some}
  * @see {@link and}
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export function every<A>(collection: Iterable<Predicate<A>>): Predicate<A> {
@@ -2791,17 +2810,17 @@ export function every<A>(collection: Iterable<Predicate<A>>): Predicate<A> {
  *
  * **Example** (Checking any predicate)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const anyCheck = Predicate.some([Predicate.isString, Predicate.isNumber])
  *
- * console.log(anyCheck("ok"))
+ * anyCheck("ok") // => true
  * ```
  *
  * @see {@link every}
  * @see {@link or}
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export function some<A>(collection: Iterable<Predicate<A>>): Predicate<A> {