effect 2.0.0-next.42 → 2.0.0-next.44

package/Predicate/dist/effect-Predicate.cjs.prod.js

@@ -2,47 +2,675 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-var Predicate_dist_effectPredicate = require('../../dist/Predicate-daa86e61.cjs.prod.js');
-
-
-
-exports.all = Predicate_dist_effectPredicate.all;
-exports.and = Predicate_dist_effectPredicate.and;
-exports.compose = Predicate_dist_effectPredicate.compose;
-exports.eqv = Predicate_dist_effectPredicate.eqv;
-exports.every = Predicate_dist_effectPredicate.every;
-exports.implies = Predicate_dist_effectPredicate.implies;
-exports.isBigint = Predicate_dist_effectPredicate.isBigint;
-exports.isBoolean = Predicate_dist_effectPredicate.isBoolean;
-exports.isDate = Predicate_dist_effectPredicate.isDate;
-exports.isError = Predicate_dist_effectPredicate.isError;
-exports.isFunction = Predicate_dist_effectPredicate.isFunction;
-exports.isIterable = Predicate_dist_effectPredicate.isIterable;
-exports.isNever = Predicate_dist_effectPredicate.isNever;
-exports.isNotNull = Predicate_dist_effectPredicate.isNotNull;
-exports.isNotNullable = Predicate_dist_effectPredicate.isNotNullable;
-exports.isNotUndefined = Predicate_dist_effectPredicate.isNotUndefined;
-exports.isNull = Predicate_dist_effectPredicate.isNull;
-exports.isNullable = Predicate_dist_effectPredicate.isNullable;
-exports.isNumber = Predicate_dist_effectPredicate.isNumber;
-exports.isObject = Predicate_dist_effectPredicate.isObject;
-exports.isReadonlyRecord = Predicate_dist_effectPredicate.isReadonlyRecord;
-exports.isRecord = Predicate_dist_effectPredicate.isRecord;
-exports.isString = Predicate_dist_effectPredicate.isString;
-exports.isSymbol = Predicate_dist_effectPredicate.isSymbol;
-exports.isTagged = Predicate_dist_effectPredicate.isTagged;
-exports.isUint8Array = Predicate_dist_effectPredicate.isUint8Array;
-exports.isUndefined = Predicate_dist_effectPredicate.isUndefined;
-exports.isUnknown = Predicate_dist_effectPredicate.isUnknown;
-exports.mapInput = Predicate_dist_effectPredicate.mapInput;
-exports.nand = Predicate_dist_effectPredicate.nand;
-exports.nor = Predicate_dist_effectPredicate.nor;
-exports.not = Predicate_dist_effectPredicate.not;
-exports.or = Predicate_dist_effectPredicate.or;
-exports.product = Predicate_dist_effectPredicate.product;
-exports.productMany = Predicate_dist_effectPredicate.productMany;
-exports.some = Predicate_dist_effectPredicate.some;
-exports.struct = Predicate_dist_effectPredicate.struct;
-exports.tuple = Predicate_dist_effectPredicate.tuple;
-exports.xor = Predicate_dist_effectPredicate.xor;
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * Given a `Predicate<A>` returns a `Predicate<B>`
+ *
+ * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
+ * @param f - a function to transform `B` to `A`.
+ *
+ * @example
+ * import * as P from "effect/Predicate"
+ * import * as N from "effect/Number"
+ *
+ * const minLength3 = P.mapInput(N.greaterThan(2), (s: string) => s.length)
+ *
+ * assert.deepStrictEqual(minLength3("a"), false)
+ * assert.deepStrictEqual(minLength3("aa"), false)
+ * assert.deepStrictEqual(minLength3("aaa"), true)
+ * assert.deepStrictEqual(minLength3("aaaa"), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => b => self(f(b)));
+
+/**
+ * Tests if a value is a `string`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isString } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isString("a"), true)
+ *
+ * assert.deepStrictEqual(isString(1), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isString = input => typeof input === "string";
+
+/**
+ * Tests if a value is a `number`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNumber } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNumber(2), true)
+ *
+ * assert.deepStrictEqual(isNumber("2"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNumber = input => typeof input === "number";
+
+/**
+ * Tests if a value is a `boolean`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isBoolean } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isBoolean(true), true)
+ *
+ * assert.deepStrictEqual(isBoolean("true"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isBoolean = input => typeof input === "boolean";
+
+/**
+ * Tests if a value is a `bigint`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isBigint } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isBigint(1n), true)
+ *
+ * assert.deepStrictEqual(isBigint(1), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isBigint = input => typeof input === "bigint";
+
+/**
+ * Tests if a value is a `symbol`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isSymbol } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isSymbol(Symbol.for("a")), true)
+ *
+ * assert.deepStrictEqual(isSymbol("a"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isSymbol = input => typeof input === "symbol";
+
+/**
+ * Tests if a value is a `function`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isFunction } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isFunction(isFunction), true)
+ *
+ * assert.deepStrictEqual(isFunction("function"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isFunction = Function_dist_effectFunction.isFunction;
+
+/**
+ * Tests if a value is `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isUndefined } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isUndefined(undefined), true)
+ *
+ * assert.deepStrictEqual(isUndefined(null), false)
+ * assert.deepStrictEqual(isUndefined("undefined"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isUndefined = input => input === undefined;
+
+/**
+ * Tests if a value is not `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNotUndefined } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNotUndefined(null), true)
+ * assert.deepStrictEqual(isNotUndefined("undefined"), true)
+ *
+ * assert.deepStrictEqual(isNotUndefined(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNotUndefined = input => input !== undefined;
+
+/**
+ * Tests if a value is `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNull } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNull(null), true)
+ *
+ * assert.deepStrictEqual(isNull(undefined), false)
+ * assert.deepStrictEqual(isNull("null"), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNull = input => input === null;
+
+/**
+ * Tests if a value is not `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNotNull } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNotNull(undefined), true)
+ * assert.deepStrictEqual(isNotNull("null"), true)
+ *
+ * assert.deepStrictEqual(isNotNull(null), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNotNull = input => input !== null;
+
+/**
+ * A guard that always fails.
+ *
+ * @param _ - The value to test.
+ *
+ * @example
+ * import { isNever } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNever(null), false)
+ * assert.deepStrictEqual(isNever(undefined), false)
+ * assert.deepStrictEqual(isNever({}), false)
+ * assert.deepStrictEqual(isNever([]), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNever = _ => false;
+
+/**
+ * A guard that always succeeds.
+ *
+ * @param _ - The value to test.
+ *
+ * @example
+ * import { isUnknown } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isUnknown(null), true)
+ * assert.deepStrictEqual(isUnknown(undefined), true)
+ *
+ * assert.deepStrictEqual(isUnknown({}), true)
+ * assert.deepStrictEqual(isUnknown([]), true)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isUnknown = _ => true;
+
+/**
+ * Tests if a value is an `object`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isObject } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isObject({}), true)
+ * assert.deepStrictEqual(isObject([]), true)
+ *
+ * assert.deepStrictEqual(isObject(null), false)
+ * assert.deepStrictEqual(isObject(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isObject = input => typeof input === "object" && input != null || isFunction(input);
+
+/**
+ * Tests if a value is an `object` with a property `_tag` that matches the given tag.
+ *
+ * @param input - The value to test.
+ * @param tag - The tag to test for.
+ *
+ * @example
+ * import { isTagged } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isTagged(1, "a"), false)
+ * assert.deepStrictEqual(isTagged(null, "a"), false)
+ * assert.deepStrictEqual(isTagged({}, "a"), false)
+ * assert.deepStrictEqual(isTagged({ a: "a" }, "a"), false)
+ * assert.deepStrictEqual(isTagged({ _tag: "a" }, "a"), true)
+ * assert.deepStrictEqual(isTagged("a")({ _tag: "a" }), true)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isTagged = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, tag) => isObject(self) && "_tag" in self && self["_tag"] === tag);
+
+/**
+ * A guard that succeeds when the input is `null` or `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNullable } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNullable(null), true)
+ * assert.deepStrictEqual(isNullable(undefined), true)
+ *
+ * assert.deepStrictEqual(isNullable({}), false)
+ * assert.deepStrictEqual(isNullable([]), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNullable = input => input === null || input === undefined;
+
+/**
+ * A guard that succeeds when the input is not `null` or `undefined`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isNotNullable } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isNotNullable({}), true)
+ * assert.deepStrictEqual(isNotNullable([]), true)
+ *
+ * assert.deepStrictEqual(isNotNullable(null), false)
+ * assert.deepStrictEqual(isNotNullable(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isNotNullable = input => input !== null && input !== undefined;
+
+/**
+ * A guard that succeeds when the input is an `Error`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isError } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isError(new Error()), true)
+ *
+ * assert.deepStrictEqual(isError(null), false)
+ * assert.deepStrictEqual(isError({}), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isError = input => input instanceof Error;
+
+/**
+ * A guard that succeeds when the input is a `Uint8Array`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isUint8Array } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isUint8Array(new Uint8Array()), true)
+ *
+ * assert.deepStrictEqual(isUint8Array(null), false)
+ * assert.deepStrictEqual(isUint8Array({}), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isUint8Array = input => input instanceof Uint8Array;
+
+/**
+ * A guard that succeeds when the input is a `Date`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isDate } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isDate(new Date()), true)
+ *
+ * assert.deepStrictEqual(isDate(null), false)
+ * assert.deepStrictEqual(isDate({}), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isDate = input => input instanceof Date;
+
+/**
+ * A guard that succeeds when the input is an `Iterable`.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isIterable } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isIterable([]), true)
+ * assert.deepStrictEqual(isIterable(new Set()), true)
+ *
+ * assert.deepStrictEqual(isIterable(null), false)
+ * assert.deepStrictEqual(isIterable({}), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isIterable = input => isObject(input) && Symbol.iterator in input;
+
+/**
+ * A guard that succeeds when the input is a record.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isRecord } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isRecord({}), true)
+ * assert.deepStrictEqual(isRecord({ a: 1 }), true)
+ *
+ * assert.deepStrictEqual(isRecord([]), false)
+ * assert.deepStrictEqual(isRecord([1, 2, 3]), false)
+ * assert.deepStrictEqual(isRecord(null), false)
+ * assert.deepStrictEqual(isRecord(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isRecord = input => isObject(input) && !Array.isArray(input);
+
+/**
+ * A guard that succeeds when the input is a readonly record.
+ *
+ * @param input - The value to test.
+ *
+ * @example
+ * import { isReadonlyRecord } from "effect/Predicate"
+ *
+ * assert.deepStrictEqual(isReadonlyRecord({}), true)
+ * assert.deepStrictEqual(isReadonlyRecord({ a: 1 }), true)
+ *
+ * assert.deepStrictEqual(isReadonlyRecord([]), false)
+ * assert.deepStrictEqual(isReadonlyRecord([1, 2, 3]), false)
+ * assert.deepStrictEqual(isReadonlyRecord(null), false)
+ * assert.deepStrictEqual(isReadonlyRecord(undefined), false)
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isReadonlyRecord = isRecord;
+
+/**
+ * @since 2.0.0
+ */
+const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (ab, bc) => a => ab(a) && bc(a));
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const product = (self, that) => ([a, b]) => self(a) && that(b);
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const all = collection => {
+  return as => {
+    let collectionIndex = 0;
+    for (const p of collection) {
+      if (collectionIndex >= as.length) {
+        break;
+      }
+      if (p(as[collectionIndex]) === false) {
+        return false;
+      }
+      collectionIndex++;
+    }
+    return true;
+  };
+};
+
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+const productMany = (self, collection) => {
+  const rest = all(collection);
+  return ([head, ...tail]) => self(head) === false ? false : rest(tail);
+};
+
+/**
+ * Similar to `Promise.all` but operates on `Predicate`s.
+ *
+ * ```
+ * [Predicate<A>, Predicate<B>, ...] -> Predicate<[A, B, ...]>
+ * ```
+ *
+ * @since 2.0.0
+ */
+const tuple = (...elements) => all(elements);
+
+/**
+ * @since 2.0.0
+ */
+const struct = fields => {
+  const keys = Object.keys(fields);
+  return a => {
+    for (const key of keys) {
+      if (!fields[key](a[key])) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+
+/**
+ * Negates the result of a given predicate.
+ *
+ * @param self - A predicate.
+ *
+ * @example
+ * import * as P from "effect/Predicate"
+ * import * as N from "effect/Number"
+ *
+ * const isPositive = P.not(N.lessThan(0))
+ *
+ * assert.deepStrictEqual(isPositive(-1), false)
+ * assert.deepStrictEqual(isPositive(0), true)
+ * assert.deepStrictEqual(isPositive(1), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const not = self => a => !self(a);
+
+/**
+ * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
+ *
+ * @param self - A predicate.
+ * @param that - A predicate.
+ *
+ * @example
+ * import * as P from "effect/Predicate"
+ * import * as N from "effect/Number"
+ *
+ * const nonZero = P.or(N.lessThan(0), N.greaterThan(0))
+ *
+ * assert.deepStrictEqual(nonZero(-1), true)
+ * assert.deepStrictEqual(nonZero(0), false)
+ * assert.deepStrictEqual(nonZero(1), true)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const or = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => self(a) || that(a));
+
+/**
+ * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
+ *
+ * @param self - A predicate.
+ * @param that - A predicate.
+ *
+ * @example
+ * import * as P from "effect/Predicate"
+ *
+ * const minLength = (n: number) => (s: string) => s.length >= n
+ * const maxLength = (n: number) => (s: string) => s.length <= n
+ *
+ * const length = (n: number) => P.and(minLength(n), maxLength(n))
+ *
+ * assert.deepStrictEqual(length(2)("aa"), true)
+ * assert.deepStrictEqual(length(2)("a"), false)
+ * assert.deepStrictEqual(length(2)("aaa"), false)
+ *
+ * @category combinators
+ * @since 2.0.0
+ */
+const and = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => self(a) && that(a));
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+const xor = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => self(a) !== that(a));
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+const eqv = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => self(a) === that(a));
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+const implies = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => self(a) ? that(a) : true);
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+const nor = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => !(self(a) || that(a)));
+
+/**
+ * @category combinators
+ * @since 2.0.0
+ */
+const nand = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => a => !(self(a) && that(a)));
+
+/**
+ * @category elements
+ * @since 2.0.0
+ */
+const every = collection => a => {
+  for (const p of collection) {
+    if (!p(a)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * @category elements
+ * @since 2.0.0
+ */
+const some = collection => a => {
+  for (const p of collection) {
+    if (p(a)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+exports.all = all;
+exports.and = and;
+exports.compose = compose;
+exports.eqv = eqv;
+exports.every = every;
+exports.implies = implies;
+exports.isBigint = isBigint;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isError = isError;
+exports.isFunction = isFunction;
+exports.isIterable = isIterable;
+exports.isNever = isNever;
+exports.isNotNull = isNotNull;
+exports.isNotNullable = isNotNullable;
+exports.isNotUndefined = isNotUndefined;
+exports.isNull = isNull;
+exports.isNullable = isNullable;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isReadonlyRecord = isReadonlyRecord;
+exports.isRecord = isRecord;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTagged = isTagged;
+exports.isUint8Array = isUint8Array;
+exports.isUndefined = isUndefined;
+exports.isUnknown = isUnknown;
+exports.mapInput = mapInput;
+exports.nand = nand;
+exports.nor = nor;
+exports.not = not;
+exports.or = or;
+exports.product = product;
+exports.productMany = productMany;
+exports.some = some;
+exports.struct = struct;
+exports.tuple = tuple;
+exports.xor = xor;