occam-verify-cli 1.0.806 → 1.0.814

package/lib/context/synoptic.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SynopticContext;
+    }
+});
+const _necessary = require("necessary");
+const _context = /*#__PURE__*/ _interop_require_default(require("../context"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { push, last, compress } = _necessary.arrayUtilities;
+class SynopticContext extends _context.default {
+    constructor(context, contexts){
+        super(context);
+        this.contexts = contexts;
+    }
+    getContexts() {
+        return this.contexts;
+    }
+    getTerms() {
+        const terms = [];
+        this.contexts.forEach((context)=>{
+            const contextTerms = context.getTerms();
+            push(terms, contextTerms);
+        });
+        compress(terms, (termA, termB)=>{
+            const termAComparesToTermB = termA.compareTerm(termB);
+            if (!termAComparesToTermB) {
+                return true;
+            }
+        });
+        return terms;
+    }
+    getFrames() {
+        const frames = [];
+        this.contexts.forEach((context)=>{
+            const contextFrames = context.getFrames();
+            push(frames, contextFrames);
+        });
+        compress(frames, (frameA, frameB)=>{
+            const frameAEqualToFrameB = frameA.isEqualTo(frameB);
+            if (!frameAEqualToFrameB) {
+                return true;
+            }
+        });
+        return frames;
+    }
+    getEqualities() {
+        const equalities = [];
+        this.contexts.forEach((context)=>{
+            const contextEqualities = context.getEqualities();
+            push(equalities, contextEqualities);
+        });
+        compress(equalities, (equalityA, equalityB)=>{
+            const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+            if (!equalityAEqualToEqualityB) {
+                return true;
+            }
+        });
+        return equalities;
+    }
+    getJudgements() {
+        const judgements = [];
+        this.contexts.forEach((context)=>{
+            const contextJudgements = context.getJudgements();
+            push(judgements, contextJudgements);
+        });
+        compress(judgements, (judgementA, judgementB)=>{
+            const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);
+            if (!judgementAEqualToJudgementB) {
+                return true;
+            }
+        });
+        return judgements;
+    }
+    getStatements() {
+        const statements = [];
+        this.contexts.forEach((context)=>{
+            const contextStatements = context.getStatements();
+            push(statements, contextStatements);
+        });
+        compress(statements, (statementA, statementB)=>{
+            const statementAEqualToStatementB = statementA.isEqualTo(statementB);
+            if (!statementAEqualToStatementB) {
+                return true;
+            }
+        });
+        return statements;
+    }
+    getAssertions() {
+        const assertions = [];
+        this.contexts.forEach((context)=>{
+            const contextAssertions = context.getAssertions();
+            push(assertions, contextAssertions);
+        });
+        compress(assertions, (assertionA, assertionB)=>{
+            const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+            if (!assertionAEqualToAssertionB) {
+                return true;
+            }
+        });
+        return assertions;
+    }
+    getReferences() {
+        const references = [];
+        this.contexts.forEach((context)=>{
+            const contextReferences = context.getReferences();
+            push(references, contextReferences);
+        });
+        compress(references, (referenceA, referenceB)=>{
+            const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+            if (!referenceAEqualToReferenceB) {
+                return true;
+            }
+        });
+        return references;
+    }
+    getAssumptions() {
+        const assumptions = [];
+        this.contexts.forEach((context)=>{
+            const contextAssumptions = context.getAssumptions();
+            push(assumptions, contextAssumptions);
+        });
+        compress(assumptions, (assumptionA, assumptionB)=>{
+            const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+            if (!assumptionAEqualToAssumptionB) {
+                return true;
+            }
+        });
+        return assumptions;
+    }
+    getMetavariables() {
+        const metavariables = [];
+        this.contexts.forEach((context)=>{
+            const contextMetavariables = context.getMetavariables();
+            push(metavariables, contextMetavariables);
+        });
+        compress(metavariables, (metavariableA, metavariableB)=>{
+            const metavariableAEqualToMetavariableB = metavariableA.isEqualTo(metavariableB);
+            if (!metavariableAEqualToMetavariableB) {
+                return true;
+            }
+        });
+        return metavariables;
+    }
+    getSubstitutions() {
+        const substitutions = [];
+        this.contexts.forEach((context)=>{
+            const contextSubstitutions = context.getSubstitutions();
+            push(substitutions, contextSubstitutions);
+        });
+        compress(substitutions, (substitutionA, substitutionB)=>{
+            const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+            if (!substitutionAEqualToSubstitutionB) {
+                return true;
+            }
+        });
+        return substitutions;
+    }
+    findTermByTermNode(termNode) {
+        const terms = this.getTerms(), term = terms.find((term)=>{
+            const termNodeMatches = term.matchTermNode(termNode);
+            if (termNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return term;
+    }
+    findFrameByFrameNode(frameNode) {
+        const frames = this.getFrames(), frame = frames.find((frame)=>{
+            const frameNodeMatches = frame.matchFrameNode(frameNode);
+            if (frameNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return frame;
+    }
+    findEqualityByEqualityNode(equalityNode) {
+        const equalities = this.getEqualities(), equality = equalities.find((equality)=>{
+            const equalityNodeMatches = equality.matchEqualityNode(equalityNode);
+            if (equalityNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return equality;
+    }
+    findJudgementByJudgementNode(judgementNode) {
+        const judgements = this.getJudgements(), judgement = judgements.find((judgement)=>{
+            const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);
+            if (judgementNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return judgement;
+    }
+    findStatementByStatementNode(statementNode) {
+        const statements = this.getStatements(), statement = statements.find((statement)=>{
+            const statementNodeMatches = statement.matchStatementNode(statementNode);
+            if (statementNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return statement;
+    }
+    findReferenceByReferenceNode(referenceNode) {
+        const references = this.getReferences(), reference = references.find((reference)=>{
+            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
+            if (referenceMatcheReferenceNode) {
+                return true;
+            }
+        }) || null;
+        return reference;
+    }
+    findAssertionByAssertionNode(assertionNode) {
+        const assertions = this.getAssertions(), assertion = assertions.find((assertion)=>{
+            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+            if (assertionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return assertion;
+    }
+    findAssumptionByAssumptionNode(assumptionNode) {
+        const assumptions = this.getAssumptions(), assumption = assumptions.find((assumption)=>{
+            const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
+            if (assumptionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return assumption;
+    }
+    findReferenceByMetavariableNode(metavariableNode) {
+        const references = this.getReferences(), reference = references.find((reference)=>{
+            const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
+            if (referenceMatcheMetavariableNode) {
+                return true;
+            }
+        }) || null;
+        return reference;
+    }
+    findMetavariableByMetavariableNode(metavariableNode) {
+        const metavariables = this.getMetavariables(), metavariable = metavariables.find((metavariable)=>{
+            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
+            if (metavariableNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return metavariable;
+    }
+    findSubstitutionBySubstitutionNode(substitutionNode) {
+        const substitutions = this.getSubstitutions(), substitution = substitutions.find((substitution)=>{
+            const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
+            if (substitutionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return substitution;
+    }
+    static fromContexts(...contexts) {
+        const lastContext = last(contexts), context = lastContext, synopticContext = new SynopticContext(context, contexts);
+        return synopticContext;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/synoptic.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport Context from \"../context\";\n\nconst { push, last, compress } = arrayUtilities;\n\nexport default class SynopticContext extends Context {\n  constructor(context, contexts) {\n    super(context);\n\n    this.contexts = contexts;\n  }\n\n  getContexts() {\n    return this.contexts;\n  }\n\n  getTerms() {\n    const terms = [];\n\n    this.contexts.forEach((context) => {\n      const contextTerms = context.getTerms();\n\n      push(terms, contextTerms);\n    });\n    \n    compress(terms, (termA, termB) => {\n      const termAComparesToTermB = termA.compareTerm(termB);\n      \n      if (!termAComparesToTermB) {\n        return true;\n      }\n    });\n\n    return terms;\n  }\n\n  getFrames() {\n    const frames = [];\n\n    this.contexts.forEach((context) => {\n      const contextFrames = context.getFrames();\n\n      push(frames, contextFrames);\n    });\n\n    compress(frames, (frameA, frameB) => {\n      const frameAEqualToFrameB = frameA.isEqualTo(frameB);\n\n      if (!frameAEqualToFrameB) {\n        return true;\n      }\n    });\n\n    return frames;\n  }\n\n  getEqualities() {\n    const equalities = [];\n\n    this.contexts.forEach((context) => {\n      const contextEqualities = context.getEqualities();\n\n      push(equalities, contextEqualities);\n    });\n\n    compress(equalities, (equalityA, equalityB) => {\n      const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);\n\n      if (!equalityAEqualToEqualityB) {\n        return true;\n      }\n    });\n\n    return equalities;\n  }\n\n  getJudgements() {\n    const judgements = [];\n\n    this.contexts.forEach((context) => {\n      const contextJudgements = context.getJudgements();\n\n      push(judgements, contextJudgements);\n    });\n\n    compress(judgements, (judgementA, judgementB) => {\n      const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);\n\n      if (!judgementAEqualToJudgementB) {\n        return true;\n      }\n    });\n\n    return judgements;\n  }\n\n  getStatements() {\n    const statements = [];\n\n    this.contexts.forEach((context) => {\n      const contextStatements = context.getStatements();\n\n      push(statements, contextStatements);\n    });\n\n    compress(statements, (statementA, statementB) => {\n      const statementAEqualToStatementB = statementA.isEqualTo(statementB);\n\n      if (!statementAEqualToStatementB) {\n        return true;\n      }\n    });\n\n    return statements;\n  }\n\n  getAssertions() {\n    const assertions = [];\n\n    this.contexts.forEach((context) => {\n      const contextAssertions = context.getAssertions();\n\n      push(assertions, contextAssertions);\n    });\n\n    compress(assertions, (assertionA, assertionB) => {\n      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);\n\n      if (!assertionAEqualToAssertionB) {\n        return true;\n      }\n    });\n\n    return assertions;\n  }\n\n  getReferences() {\n    const references = [];\n\n    this.contexts.forEach((context) => {\n      const contextReferences = context.getReferences();\n\n      push(references, contextReferences);\n    });\n\n    compress(references, (referenceA, referenceB) => {\n      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);\n\n      if (!referenceAEqualToReferenceB) {\n        return true;\n      }\n    });\n\n    return references;\n  }\n\n  getAssumptions() {\n    const assumptions = [];\n\n    this.contexts.forEach((context) => {\n      const contextAssumptions = context.getAssumptions();\n\n      push(assumptions, contextAssumptions);\n    });\n\n    compress(assumptions, (assumptionA, assumptionB) => {\n      const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);\n\n      if (!assumptionAEqualToAssumptionB) {\n        return true;\n      }\n    });\n\n    return assumptions;\n  }\n\n  getMetavariables() {\n    const metavariables = [];\n\n    this.contexts.forEach((context) => {\n      const contextMetavariables = context.getMetavariables();\n\n      push(metavariables, contextMetavariables);\n    });\n\n    compress(metavariables, (metavariableA, metavariableB) => {\n      const metavariableAEqualToMetavariableB = metavariableA.isEqualTo(metavariableB);\n\n      if (!metavariableAEqualToMetavariableB) {\n        return true;\n      }\n    });\n\n    return metavariables;\n  }\n\n  getSubstitutions() {\n    const substitutions = [];\n\n    this.contexts.forEach((context) => {\n      const contextSubstitutions = context.getSubstitutions();\n\n      push(substitutions, contextSubstitutions);\n    });\n\n    compress(substitutions, (substitutionA, substitutionB) => {\n      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);\n\n      if (!substitutionAEqualToSubstitutionB) {\n        return true;\n      }\n    });\n\n    return substitutions;\n  }\n\n  findTermByTermNode(termNode) {\n    const terms = this.getTerms(),\n          term = terms.find((term) => {\n            const termNodeMatches = term.matchTermNode(termNode);\n\n            if (termNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return term;\n  }\n\n  findFrameByFrameNode(frameNode) {\n    const frames = this.getFrames(),\n          frame = frames.find((frame) => {\n            const frameNodeMatches = frame.matchFrameNode(frameNode);\n\n            if (frameNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return frame;\n  }\n\n  findEqualityByEqualityNode(equalityNode) {\n    const equalities = this.getEqualities(),\n          equality = equalities.find((equality) => {\n            const equalityNodeMatches = equality.matchEqualityNode(equalityNode);\n\n            if (equalityNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return equality;\n  }\n\n  findJudgementByJudgementNode(judgementNode) {\n    const judgements = this.getJudgements(),\n          judgement = judgements.find((judgement) => {\n            const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);\n\n            if (judgementNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return judgement;\n  }\n\n  findStatementByStatementNode(statementNode) {\n    const statements = this.getStatements(),\n          statement = statements.find((statement) => {\n            const statementNodeMatches = statement.matchStatementNode(statementNode);\n\n            if (statementNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return statement;\n  }\n\n  findReferenceByReferenceNode(referenceNode) {\n    const references = this.getReferences(),\n          reference = references.find((reference) => {\n            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);\n\n            if (referenceMatcheReferenceNode) {\n              return true;\n            }\n          }) || null;\n\n    return reference;\n  }\n\n  findAssertionByAssertionNode(assertionNode) {\n    const assertions = this.getAssertions(),\n          assertion = assertions.find((assertion) => {\n            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);\n\n            if (assertionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return assertion;\n  }\n\n  findAssumptionByAssumptionNode(assumptionNode) {\n    const assumptions = this.getAssumptions(),\n          assumption = assumptions.find((assumption) => {\n            const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);\n\n            if (assumptionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return assumption;\n  }\n\n  findReferenceByMetavariableNode(metavariableNode) {\n    const references = this.getReferences(),\n          reference = references.find((reference) => {\n            const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);\n\n            if (referenceMatcheMetavariableNode) {\n              return true;\n            }\n          }) || null;\n\n    return reference;\n  }\n\n  findMetavariableByMetavariableNode(metavariableNode) {\n    const metavariables = this.getMetavariables(),\n          metavariable = metavariables.find((metavariable) => {\n            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);\n\n            if (metavariableNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return metavariable;\n  }\n\n  findSubstitutionBySubstitutionNode(substitutionNode) {\n    const substitutions = this.getSubstitutions(),\n          substitution = substitutions.find((substitution) => {\n            const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);\n\n            if (substitutionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return substitution;\n  }\n\n  static fromContexts(...contexts) {\n    const lastContext = last(contexts),\n          context = lastContext,  ///\n          synopticContext = new SynopticContext(context, contexts);\n\n    return synopticContext;\n  }\n}\n"],"names":["SynopticContext","push","last","compress","arrayUtilities","Context","context","contexts","getContexts","getTerms","terms","forEach","contextTerms","termA","termB","termAComparesToTermB","compareTerm","getFrames","frames","contextFrames","frameA","frameB","frameAEqualToFrameB","isEqualTo","getEqualities","equalities","contextEqualities","equalityA","equalityB","equalityAEqualToEqualityB","getJudgements","judgements","contextJudgements","judgementA","judgementB","judgementAEqualToJudgementB","getStatements","statements","contextStatements","statementA","statementB","statementAEqualToStatementB","getAssertions","assertions","contextAssertions","assertionA","assertionB","assertionAEqualToAssertionB","getReferences","references","contextReferences","referenceA","referenceB","referenceAEqualToReferenceB","getAssumptions","assumptions","contextAssumptions","assumptionA","assumptionB","assumptionAEqualToAssumptionB","getMetavariables","metavariables","contextMetavariables","metavariableA","metavariableB","metavariableAEqualToMetavariableB","getSubstitutions","substitutions","contextSubstitutions","substitutionA","substitutionB","substitutionAEqualToSubstitutionB","findTermByTermNode","termNode","term","find","termNodeMatches","matchTermNode","findFrameByFrameNode","frameNode","frame","frameNodeMatches","matchFrameNode","findEqualityByEqualityNode","equalityNode","equality","equalityNodeMatches","matchEqualityNode","findJudgementByJudgementNode","judgementNode","judgement","judgementNodeMatches","matchJudgementNode","findStatementByStatementNode","statementNode","statement","statementNodeMatches","matchStatementNode","findReferenceByReferenceNode","referenceNode","reference","referenceMatcheReferenceNode","matchReferenceNode","findAssertionByAssertionNode","assertionNode","assertion","assertionNodeMatches","matchAssertionNode","findAssumptionByAssumptionNode","assumptionNode","assumption","assumptionNodeMatches","matchAssumptionNode","findReferenceByMetavariableNode","metavariableNode","referenceMatcheMetavariableNode","matchMetavariableNode","findMetavariableByMetavariableNode","metavariable","metavariableNodeMatches","findSubstitutionBySubstitutionNode","substitutionNode","substitution","substitutionNodeMatches","matchSubstitutionNode","fromContexts","lastContext","synopticContext"],"mappings":"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"}