logiq/dist/utils.js

Awesome logical and bitwise operators with support for TypedArrays

function toVariadic(connective) {
    return (p, q, ...args) => {
        let result = connective(p, q);
        // Apply connective from left to right
        for (const arg of args) {
            result = connective(result, arg);
        }
        return result;
    };
}
export function makeConnectives(args) {
    var _a, _b, _c, _d, _e, _f;
    const { not, and, or } = args;
    const xor = (p, q) => and(or(p, q), or(not(p), not(q)));
    const imply = (p, q) => or(not(p), q);
    const nand = (p, q) => not(and(p, q));
    const nor = (p, q) => not(or(p, q));
    const xnor = (p, q) => not(xor(p, q));
    const nimply = (p, q) => not(imply(p, q));
    return {
        not,
        and: toVariadic(and),
        or: toVariadic(or),
        xor: toVariadic((_a = args.xor) !== null && _a !== void 0 ? _a : xor),
        imply: toVariadic((_b = args.imply) !== null && _b !== void 0 ? _b : imply),
        nand: toVariadic((_c = args.nand) !== null && _c !== void 0 ? _c : nand),
        nor: toVariadic((_d = args.nor) !== null && _d !== void 0 ? _d : nor),
        xnor: toVariadic((_e = args.xnor) !== null && _e !== void 0 ? _e : xnor),
        nimply: toVariadic((_f = args.nimply) !== null && _f !== void 0 ? _f : nimply),
    };
}