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

package/dist/Predicate.d.ts

@@ -16,12 +16,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}
@@ -48,15 +48,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 {
@@ -78,14 +81,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"
  * }
  * ```
  *
@@ -113,11 +116,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}
@@ -140,11 +145,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}
@@ -166,10 +173,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}
@@ -193,12 +203,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}
@@ -220,11 +232,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}
@@ -247,11 +261,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}
@@ -272,10 +288,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}
@@ -300,14 +319,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}
@@ -332,14 +351,14 @@ export declare 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}
@@ -364,14 +383,14 @@ export declare 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}
@@ -397,12 +416,12 @@ export declare 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}
@@ -426,12 +445,12 @@ export declare 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}
@@ -455,12 +474,12 @@ export declare 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}
@@ -485,12 +504,12 @@ export declare 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}
@@ -514,12 +533,12 @@ export declare 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}
@@ -543,12 +562,12 @@ export declare 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}
@@ -573,18 +592,16 @@ export declare 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 declare function isTruthy(input: unknown): boolean;
@@ -601,13 +618,13 @@ export declare 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
  * }
  * ```
  *
@@ -630,13 +647,13 @@ export declare 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
  * }
  * ```
  *
@@ -660,13 +677,13 @@ export declare 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"
  * }
  * ```
  *
@@ -691,13 +708,13 @@ export declare 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
  * }
  * ```
  *
@@ -721,13 +738,13 @@ export declare 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"
  * }
  * ```
  *
@@ -751,13 +768,13 @@ export declare 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
  * }
  * ```
  *
@@ -780,13 +797,13 @@ export declare 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"
  * }
  * ```
  *
@@ -809,14 +826,14 @@ export declare 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"
  * }
  * ```
  *
@@ -841,13 +858,13 @@ export declare 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
  * }
  * ```
  *
@@ -870,12 +887,12 @@ export declare 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}
@@ -898,13 +915,11 @@ export declare 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}
@@ -926,12 +941,12 @@ export declare function isNotUndefined<A>(input: A): input is Exclude<A, undefin
  *
  * **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}
@@ -954,13 +969,11 @@ export declare 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}
@@ -982,13 +995,11 @@ export declare 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}
@@ -1012,13 +1023,11 @@ export declare 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}
@@ -1037,10 +1046,10 @@ export declare 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}
@@ -1057,10 +1066,10 @@ export declare 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}
@@ -1082,10 +1091,10 @@ export declare 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}
@@ -1112,11 +1121,11 @@ export declare function isObjectOrArray(input: unknown): input is {
  *
  * **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}
@@ -1144,12 +1153,12 @@ export declare function isObject(input: unknown): input is {
  *
  * **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}
@@ -1173,11 +1182,11 @@ export declare function isReadonlyObject(input: unknown): input is {
  *
  * **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}
@@ -1201,14 +1210,14 @@ export declare 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"
  * }
  * ```
  *
@@ -1233,14 +1242,14 @@ export declare 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"
      * }
      * ```
      *
@@ -1267,14 +1276,14 @@ export declare 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"
      * }
      * ```
      *
@@ -1301,12 +1310,12 @@ export declare 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}
@@ -1328,12 +1337,12 @@ export declare 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}
@@ -1357,12 +1366,12 @@ export declare 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}
@@ -1386,12 +1395,12 @@ export declare 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}
@@ -1412,12 +1421,12 @@ export declare 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}
@@ -1439,12 +1448,12 @@ export declare 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}
@@ -1465,12 +1474,12 @@ export declare 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}
@@ -1492,12 +1501,12 @@ export declare 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}
@@ -1519,12 +1528,12 @@ export declare 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}
@@ -1545,12 +1554,12 @@ export declare function isPromiseLike(input: unknown): input is PromiseLike<unkn
  *
  * **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}
@@ -1573,7 +1582,7 @@ export declare 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"
@@ -1581,7 +1590,7 @@ export declare function isRegExp(input: unknown): input is RegExp;
  *
  * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
  *
- * console.log(isIntegerNumber(1))
+ * isIntegerNumber(1) // => true
  * ```
  *
  * @see {@link and}
@@ -1605,7 +1614,7 @@ export declare 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"
@@ -1613,7 +1622,7 @@ export declare const compose: {
      *
      * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
      *
-     * console.log(isIntegerNumber(1))
+     * isIntegerNumber(1) // => true
      * ```
      *
      * @see {@link and}
@@ -1637,7 +1646,7 @@ export declare 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"
@@ -1645,7 +1654,7 @@ export declare const compose: {
      *
      * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
      *
-     * console.log(isIntegerNumber(1))
+     * isIntegerNumber(1) // => true
      * ```
      *
      * @see {@link and}
@@ -1669,7 +1678,7 @@ export declare 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"
@@ -1677,7 +1686,7 @@ export declare const compose: {
      *
      * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
      *
-     * console.log(isIntegerNumber(1))
+     * isIntegerNumber(1) // => true
      * ```
      *
      * @see {@link and}
@@ -1701,7 +1710,7 @@ export declare 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"
@@ -1709,7 +1718,7 @@ export declare const compose: {
      *
      * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
      *
-     * console.log(isIntegerNumber(1))
+     * isIntegerNumber(1) // => true
      * ```
      *
      * @see {@link and}
@@ -1734,12 +1743,12 @@ export declare 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}
@@ -1769,7 +1778,7 @@ export declare function Tuple<const T extends ReadonlyArray<Predicate.Any>>(elem
  *
  * **Example** (Checking structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const userCheck = Predicate.Struct({
@@ -1777,7 +1786,7 @@ export declare function Tuple<const T extends ReadonlyArray<Predicate.Any>>(elem
  *   name: Predicate.isString
  * })
  *
- * console.log(userCheck({ id: 1, name: "Ada" }))
+ * userCheck({ id: 1, name: "Ada" }) // => true
  * ```
  *
  * @see {@link Tuple}
@@ -1805,12 +1814,12 @@ export declare function Struct<R extends Record<string, Predicate.Any>>(fields:
  *
  * **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}
@@ -1835,12 +1844,12 @@ export declare 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}
@@ -1864,12 +1873,12 @@ export declare 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}
@@ -1893,12 +1902,12 @@ export declare 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}
@@ -1922,12 +1931,12 @@ export declare 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}
@@ -1951,12 +1960,12 @@ export declare 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}
@@ -1982,7 +1991,7 @@ export declare const or: {
  *
  * **Example** (Checking both conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const hasAAndB = Predicate.and(
@@ -1995,6 +2004,8 @@ export declare const or: {
  *   // input has both properties at this point
  *   const a = input.a
  *   const b = input.b
+ *
+ *   const values = [a, b] // => [1, "ok"]
  * }
  * ```
  *
@@ -2020,7 +2031,7 @@ export declare const and: {
      *
      * **Example** (Checking both conditions)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Predicate } from "effect"
      *
      * const hasAAndB = Predicate.and(
@@ -2033,6 +2044,8 @@ export declare const and: {
      *   // input has both properties at this point
      *   const a = input.a
      *   const b = input.b
+     *
+     *   const values = [a, b] // => [1, "ok"]
      * }
      * ```
      *
@@ -2058,7 +2071,7 @@ export declare const and: {
      *
      * **Example** (Checking both conditions)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Predicate } from "effect"
      *
      * const hasAAndB = Predicate.and(
@@ -2071,6 +2084,8 @@ export declare const and: {
      *   // input has both properties at this point
      *   const a = input.a
      *   const b = input.b
+     *
+     *   const values = [a, b] // => [1, "ok"]
      * }
      * ```
      *
@@ -2096,7 +2111,7 @@ export declare const and: {
      *
      * **Example** (Checking both conditions)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Predicate } from "effect"
      *
      * const hasAAndB = Predicate.and(
@@ -2109,6 +2124,8 @@ export declare const and: {
      *   // input has both properties at this point
      *   const a = input.a
      *   const b = input.b
+     *
+     *   const values = [a, b] // => [1, "ok"]
      * }
      * ```
      *
@@ -2134,7 +2151,7 @@ export declare const and: {
      *
      * **Example** (Checking both conditions)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Predicate } from "effect"
      *
      * const hasAAndB = Predicate.and(
@@ -2147,6 +2164,8 @@ export declare const and: {
      *   // input has both properties at this point
      *   const a = input.a
      *   const b = input.b
+     *
+     *   const values = [a, b] // => [1, "ok"]
      * }
      * ```
      *
@@ -2170,14 +2189,14 @@ export declare 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}
@@ -2199,14 +2218,14 @@ export declare 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}
@@ -2228,14 +2247,14 @@ export declare 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}
@@ -2258,13 +2277,13 @@ export declare 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}
@@ -2285,13 +2304,13 @@ export declare 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}
@@ -2312,13 +2331,13 @@ export declare 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}
@@ -2342,14 +2361,14 @@ export declare 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}
@@ -2373,14 +2392,14 @@ export declare 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}
@@ -2404,14 +2423,14 @@ export declare 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}
@@ -2434,12 +2453,12 @@ export declare 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}
@@ -2461,12 +2480,12 @@ export declare 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}
@@ -2488,12 +2507,12 @@ export declare 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}
@@ -2516,12 +2535,12 @@ export declare 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}
@@ -2543,12 +2562,12 @@ export declare 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}
@@ -2570,12 +2589,12 @@ export declare 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}
@@ -2599,17 +2618,17 @@ export declare 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 declare function every<A>(collection: Iterable<Predicate<A>>): Predicate<A>;
@@ -2627,17 +2646,17 @@ export declare function every<A>(collection: Iterable<Predicate<A>>): Predicate<
  *
  * **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 declare function some<A>(collection: Iterable<Predicate<A>>): Predicate<A>;