@typed/fp/cjs/Eq.js

Data Structures and Resources for fp-ts

"use strict";
/**
 * Eq Instance for some common scenarios including deep equality.
 *
 * @since 0.9.2
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.Schemable = exports.sum = exports.lazy = exports.intersect = exports.record = exports.array = exports.partial = exports.struct = exports.tuple = exports.optional = exports.nullable = exports.unknownRecord = exports.unknownArray = exports.boolean = exports.number = exports.string = exports.deepEqualsEq = exports.neverEqualsEq = exports.alwaysEqualsEq = void 0;
const tslib_1 = require("tslib");
const fast_deep_equal_1 = (0, tslib_1.__importDefault)(require("fast-deep-equal"));
const B = (0, tslib_1.__importStar)(require("fp-ts/boolean"));
const D = (0, tslib_1.__importStar)(require("fp-ts/Date"));
const Eq = (0, tslib_1.__importStar)(require("fp-ts/Eq"));
const N = (0, tslib_1.__importStar)(require("fp-ts/number"));
const RA = (0, tslib_1.__importStar)(require("fp-ts/ReadonlyArray"));
const RR = (0, tslib_1.__importStar)(require("fp-ts/ReadonlyRecord"));
const S = (0, tslib_1.__importStar)(require("fp-ts/string"));
const function_1 = require("./function");
const internal_1 = require("./internal");
/**
 * @since 0.9.2
 * @category Instance
 */
exports.alwaysEqualsEq = { equals: (0, function_1.constant)(function_1.constTrue) };
/**
 * @since 0.9.2
 * @category Instance
 */
exports.neverEqualsEq = { equals: (0, function_1.constant)(function_1.constFalse) };
/**
 * A deep-equality Eq instance.
 * Supports Reference equality, all JavaScript Primitives including `RegExp`, `Set` and `Map`.
 * @since 0.9.2
 * @category Instance
 */
exports.deepEqualsEq = Eq.fromEquals((b) => (a) => (0, fast_deep_equal_1.default)(a, b));
// -------------------------------------------------------------------------------------
// primitives
// -------------------------------------------------------------------------------------
/**
 * @category primitives
 * @since 0.9.5
 */
exports.string = S.Eq;
/**
 * @category primitives
 * @since 0.9.5
 */
exports.number = N.Eq;
/**
 * @category primitives
 * @since 0.9.5
 */
exports.boolean = B.Eq;
/**
 * @category primitives
 * @since 0.9.5
 */
exports.unknownArray = Eq.fromEquals((second) => (first) => first.length === second.length);
/**
 * @category primitives
 * @since 0.9.5
 */
exports.unknownRecord = Eq.fromEquals((second) => (first) => {
    for (const k in first) {
        if (!(k in second)) {
            return false;
        }
    }
    for (const k in second) {
        if (!(k in first)) {
            return false;
        }
    }
    return true;
});
// -------------------------------------------------------------------------------------
// Combinator
// -------------------------------------------------------------------------------------
/**
 * @category Combinator
 * @since 0.9.5
 */
const nullable = (or) => Eq.fromEquals((second) => (first) => first === null || second === null ? first === second : or.equals(second)(first));
exports.nullable = nullable;
/**
 * @category Combinator
 * @since 0.9.5
 */
const optional = (or) => Eq.fromEquals((second) => (first) => first === undefined || second === undefined ? first === second : or.equals(second)(first));
exports.optional = optional;
/**
 * @category Combinator
 * @since 0.9.5
 */
exports.tuple = Eq.tuple;
/**
 * @category Combinator
 * @since 2.2.15
 */
exports.struct = Eq.struct;
/**
 * @category Combinator
 * @since 0.9.5
 */
const partial = (properties) => Eq.fromEquals((second) => (first) => {
    for (const k in properties) {
        const xk = first[k];
        const yk = second[k];
        if (!(xk === undefined || yk === undefined ? xk === yk : properties[k].equals(xk)(yk))) {
            return false;
        }
    }
    return true;
});
exports.partial = partial;
/**
 * @category Combinator
 * @since 0.9.5
 */
exports.array = RA.getEq;
/**
 * @category Combinator
 * @since 0.9.5
 */
exports.record = RR.getEq;
/**
 * @category Combinator
 * @since 0.9.5
 */
const intersect = (right) => (left) => Eq.fromEquals((second) => (first) => left.equals(second)(first) && right.equals(second)(first));
exports.intersect = intersect;
/**
 * @category Combinator
 * @since 0.9.5
 */
function lazy(f) {
    const get = (0, internal_1.memoize)(f);
    return {
        equals: (second) => (first) => get().equals(second)(first),
    };
}
exports.lazy = lazy;
/**
 * @category Combinator
 * @since 0.9.5
 */
const sum = (tag) => {
    return (members) => Eq.fromEquals((second) => (first) => {
        const ftag = first[tag];
        return ftag === second[tag] && members[ftag].equals(second)(first);
    });
};
exports.sum = sum;
/**
 * @category Instance
 * @since 0.9.4
 */
exports.Schemable = {
    URI: '@typed/fp/ToEq',
    string: exports.string,
    number: exports.number,
    boolean: exports.boolean,
    date: D.Eq,
    literal: () => Eq.EqStrict,
    tuple: exports.tuple,
    struct: exports.struct,
    array: exports.array,
    record: exports.record,
    nullable: exports.nullable,
    intersect: exports.intersect,
    lazy: (_, f) => lazy(f),
    sum: exports.sum,
    branded: (e) => e,
    unknownArray: exports.unknownArray,
    unknownRecord: exports.unknownRecord,
};
(0, tslib_1.__exportStar)(require("fp-ts/Eq"), exports);
//# sourceMappingURL=Eq.js.map