effect 4.0.0-beta.101 → 4.0.0-beta.103

package/dist/Predicate.js

@@ -25,14 +25,14 @@ import { dual } from "./Function.js";
  *
  * **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}
@@ -57,12 +57,12 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => b => self(f(b)));
  *
  * **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}
@@ -86,12 +86,12 @@ export const isTupleOf = /*#__PURE__*/dual(2, (self, n) => self.length === n);
  *
  * **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}
@@ -115,18 +115,16 @@ export const isTupleOfAtLeast = /*#__PURE__*/dual(2, (self, n) => self.length >=
  *
  * **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) {
@@ -145,13 +143,13 @@ export function isTruthy(input) {
  *
  * **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
  * }
  * ```
  *
@@ -176,13 +174,13 @@ export function isSet(input) {
  *
  * **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
  * }
  * ```
  *
@@ -208,13 +206,13 @@ export function isMap(input) {
  *
  * **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"
  * }
  * ```
  *
@@ -241,13 +239,13 @@ export function isString(input) {
  *
  * **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
  * }
  * ```
  *
@@ -273,13 +271,13 @@ export function isNumber(input) {
  *
  * **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"
  * }
  * ```
  *
@@ -305,13 +303,13 @@ export function isBoolean(input) {
  *
  * **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
  * }
  * ```
  *
@@ -336,13 +334,13 @@ export function isBigInt(input) {
  *
  * **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"
  * }
  * ```
  *
@@ -367,14 +365,14 @@ export function isSymbol(input) {
  *
  * **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"
  * }
  * ```
  *
@@ -401,13 +399,13 @@ export function isPropertyKey(u) {
  *
  * **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
  * }
  * ```
  *
@@ -432,12 +430,12 @@ export function isFunction(input) {
  *
  * **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}
@@ -462,13 +460,11 @@ export function isUndefined(input) {
  *
  * **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}
@@ -492,12 +488,12 @@ export function isNotUndefined(input) {
  *
  * **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}
@@ -522,13 +518,11 @@ export function isNull(input) {
  *
  * **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}
@@ -552,13 +546,11 @@ export function isNotNull(input) {
  *
  * **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}
@@ -584,13 +576,11 @@ export function isNullish(input) {
  *
  * **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}
@@ -611,10 +601,10 @@ export function isNotNullish(input) {
  *
  * **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}
@@ -633,10 +623,10 @@ export function isNever(_) {
  *
  * **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}
@@ -660,10 +650,10 @@ export function isUnknown(_) {
  *
  * **Example** (Checking objects or arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
- * console.log(Predicate.isObjectOrArray([]))
+ * Predicate.isObjectOrArray([]) // => true
  * ```
  *
  * @see {@link isObject}
@@ -690,11 +680,11 @@ export function isObjectOrArray(input) {
  *
  * **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}
@@ -722,12 +712,12 @@ export function isObject(input) {
  *
  * **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}
@@ -751,11 +741,11 @@ export function isReadonlyObject(input) {
  *
  * **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}
@@ -781,14 +771,14 @@ export function isObjectKeyword(input) {
  *
  * **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"
  * }
  * ```
  *
@@ -812,12 +802,12 @@ export const hasProperty = /*#__PURE__*/dual(2, (self, property) => isObjectKeyw
  *
  * **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}
@@ -838,12 +828,12 @@ export const isTagged = /*#__PURE__*/dual(2, (self, tag) => hasProperty(self, "_
  *
  * **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}
@@ -866,12 +856,12 @@ export function isError(input) {
  *
  * **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}
@@ -895,12 +885,12 @@ export function isUint8Array(input) {
  *
  * **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}
@@ -923,12 +913,12 @@ export function isDate(input) {
  *
  * **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}
@@ -952,12 +942,12 @@ export function isIterable(input) {
  *
  * **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}
@@ -981,12 +971,12 @@ export function isPromise(input) {
  *
  * **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}
@@ -1009,12 +999,12 @@ export function isPromiseLike(input) {
  *
  * **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}
@@ -1039,7 +1029,7 @@ export function isRegExp(input) {
  *
  * **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"
@@ -1047,7 +1037,7 @@ export function isRegExp(input) {
  *
  * const isIntegerNumber = Predicate.compose(isNumber, isInteger)
  *
- * console.log(isIntegerNumber(1))
+ * isIntegerNumber(1) // => true
  * ```
  *
  * @see {@link and}
@@ -1071,12 +1061,12 @@ export const compose = /*#__PURE__*/dual(2, (ab, bc) => a => ab(a) && bc(a));
  *
  * **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}
@@ -1109,7 +1099,7 @@ export function Tuple(elements) {
  *
  * **Example** (Checking structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const userCheck = Predicate.Struct({
@@ -1117,7 +1107,7 @@ export function Tuple(elements) {
  *   name: Predicate.isString
  * })
  *
- * console.log(userCheck({ id: 1, name: "Ada" }))
+ * userCheck({ id: 1, name: "Ada" }) // => true
  * ```
  *
  * @see {@link Tuple}
@@ -1149,12 +1139,12 @@ export function Struct(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}
@@ -1181,12 +1171,12 @@ export function not(self) {
  *
  * **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}
@@ -1211,7 +1201,7 @@ export const or = /*#__PURE__*/dual(2, (self, that) => a => self(a) || that(a));
  *
  * **Example** (Checking both conditions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Predicate } from "effect"
  *
  * const hasAAndB = Predicate.and(
@@ -1224,6 +1214,8 @@ export const or = /*#__PURE__*/dual(2, (self, that) => a => self(a) || that(a));
  *   // input has both properties at this point
  *   const a = input.a
  *   const b = input.b
+ *
+ *   const values = [a, b] // => [1, "ok"]
  * }
  * ```
  *
@@ -1246,14 +1238,14 @@ export const and = /*#__PURE__*/dual(2, (self, that) => a => self(a) && that(a))
  *
  * **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}
@@ -1275,13 +1267,13 @@ export const xor = /*#__PURE__*/dual(2, (self, that) => a => self(a) !== that(a)
  *
  * **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}
@@ -1304,14 +1296,14 @@ export const eqv = /*#__PURE__*/dual(2, (self, that) => a => self(a) === that(a)
  *
  * **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}
@@ -1333,12 +1325,12 @@ export const implies = /*#__PURE__*/dual(2, (antecedent, consequent) => a => ant
  *
  * **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}
@@ -1360,12 +1352,12 @@ export const nor = /*#__PURE__*/dual(2, (self, that) => a => !(self(a) || that(a
  *
  * **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}
@@ -1388,17 +1380,17 @@ export const nand = /*#__PURE__*/dual(2, (self, that) => a => !(self(a) && that(
  *
  * **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(collection) {
@@ -1425,17 +1417,17 @@ export function every(collection) {
  *
  * **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(collection) {