occam-verify-cli 1.0.612 → 1.0.631

package/src/context/ephemeral.js

@@ -1,20 +1,19 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import Context from "../context";
 
-const { extract } = arrayUtilities;
-
 export default class EphemeralContext extends Context {
-  constructor(context, terms, frames, statements, assertions, references, substitutions) {
+  constructor(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions) {
     super(context);
 
     this.terms = terms;
     this.frames = frames;
-    this.statements = statements;
+    this.judgements = judgements;
+    this.equalities = equalities;
     this.assertions = assertions;
+    this.statements = statements;
     this.references = references;
+    this.assumptions = assumptions;
     this.substitutions = substitutions;
   }
 
@@ -26,6 +25,14 @@ export default class EphemeralContext extends Context {
     return this.frames;
   }
 
+  getEqualities() {
+    return this.equalities;
+  }
+
+  getJudgements() {
+    return this.judgements;
+  }
+
   getStatements() {
     return this.statements;
   }
@@ -38,6 +45,10 @@ export default class EphemeralContext extends Context {
     return this.references;
   }
 
+  getAssumptions() {
+    return this.assumptions;
+  }
+
   getSubstitutions() {
     return this.substitutions;
   }
@@ -47,18 +58,24 @@ export default class EphemeralContext extends Context {
           context = this, ///
           termString = term.getString();
 
-    extract(this.terms, (term) => {
+    context.trace(`Adding the '${termString}' term to the ephemeral context...`);
+
+    const termB = this.terms.find((term) => {
       const termB = term, ///
             termAEqualToTermB = termA.isEqualTo(termB);
 
       if (termAEqualToTermB) {
         return true;
       }
-    });
+    }) || null;
 
-    context.trace(`Added the '${termString}' term to the context.`);
+    if (termB !== null) {
+      context.trace(`The '${termString}' term has already been added to the ephemeral context.`);
+    } else {
+      this.terms.push(term);
 
-    this.terms.push(term);
+      context.debug(`...added the '${termString}' term to the ephemeral context.`);
+    }
   }
 
   addFrame(frame) {
@@ -66,18 +83,74 @@ export default class EphemeralContext extends Context {
           context = this, ///
           frameString = frame.getString();
 
-    extract(this.frames, (frame) => {
+    context.trace(`Adding the '${frameString}' frame to the ephemeral context...`);
+
+    const frameB = this.frames.find((frame) => {
       const frameB = frame, ///
             frameAEqualToFrameB = frameA.isEqualTo(frameB);
 
       if (frameAEqualToFrameB) {
         return true;
       }
-    });
+    }) || null;
+
+    if (frameB !== null) {
+      context.trace(`The '${frameString}' frame has already been added to the ephemeral context.`);
+    } else {
+      this.frames.push(frame);
+
+      context.debug(`...added the '${frameString}' frame to the ephemeral context.`);
+    }
+  }
+
+  addEquality(equality) {
+    const equalityA = equality, ///
+          context = this, ///
+          equalityString = equality.getString();
+
+    context.trace(`Adding the '${equalityString}' equality to the ephemeral context...`);
+
+    const equalityB = this.equalities.find((equality) => {
+      const equalityB = equality, ///
+            equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+
+      if (equalityAEqualToEqualityB) {
+        return true;
+      }
+    }) || null;
+
+    if (equalityB !== null) {
+      context.trace(`The '${equalityString}' equality has already been added to the ephemeral context.`);
+    } else {
+      this.equalities.push(equality);
+
+      context.debug(`...added the '${equalityString}' equality to the ephemeral context.`);
+    }
+  }
+
+  addJudgement(judgement) {
+    const judgementA = judgement, ///
+          context = this, ///
+          judgementString = judgement.getString();
+
+    context.trace(`Adding the '${judgementString}' judgement to the ephemeral context...`);
+
+    const judgementB = this.judgements.find((judgement) => {
+      const judgementB = judgement, ///
+            judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);
+
+      if (judgementAEqualToEqualityB) {
+        return true;
+      }
+    }) || null;
 
-    context.trace(`Added the '${frameString}' frame to the context.`);
+    if (judgementB !== null) {
+      context.trace(`The '${judgementString}' judgement has already been added to the ephemeral context.`);
+    } else {
+      this.judgements.push(judgement);
 
-    this.frames.push(frame);
+      context.debug(`...added the '${judgementString}' judgement to the ephemeral context.`);
+    }
   }
 
   addStatement(statement) {
@@ -85,18 +158,24 @@ export default class EphemeralContext extends Context {
           statementA = statement, ///
           statementString = statement.getString();
 
-    extract(this.statements, (statement) => {
+    context.trace(`Adding the '${statementString}' statement to the ephemeral context...`);
+
+    const statementB = this.statements.find((statement) => {
       const statementB = statement, ///
-            statementAEqualToFrameB = statementA.isEqualTo(statementB);
+            statementAEqualToStatementB = statementA.isEqualTo(statementB);
 
-      if (statementAEqualToFrameB) {
+      if (statementAEqualToStatementB) {
         return true;
       }
-    });
+    }) || null;
 
-    context.trace(`Added the '${statementString}' statement to the context.`);
+    if (statementB !== null) {
+      context.trace(`The '${statementString}' statement has already been added to the ephemeral context.`);
+    } else {
+      this.statements.push(statement);
 
-    this.statements.push(statement);
+      context.debug(`...added the '${statementString}' statement to the ephemeral context.`);
+    }
   }
 
   addAssertion(assertion) {
@@ -104,18 +183,24 @@ export default class EphemeralContext extends Context {
           assertionA = assertion, ///
           assertionString = assertion.getString();
 
-    extract(this.assertions, (assertion) => {
+    context.trace(`Adding the '${assertionString}' assertion to the ephemeral context...`);
+
+    const assertionB = this.assertions.find((assertion) => {
       const assertionB = assertion, ///
             assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
 
       if (assertionAEqualToAssertionB) {
         return true;
       }
-    });
+    }) || null;
 
-    context.trace(`Added the '${assertionString}' assertion to the context.`);
+    if (assertionB !== null) {
+      context.trace(`The '${assertionString}' assertion has already been added to the ephemeral context.`);
+    } else {
+      this.assertions.push(assertion);
 
-    this.assertions.push(assertion);
+      context.debug(`...added the '${assertionString}' assertion to the ephemeral context.`);
+    }
   }
 
   addReference(reference) {
@@ -123,18 +208,49 @@ export default class EphemeralContext extends Context {
           referenceA = reference, ///
           referenceString = reference.getString();
 
-    extract(this.references, (reference) => {
+    context.trace(`Adding the '${referenceString}' reference to the ephemeral context...`);
+
+    const referenceB = this.references.find((reference) => {
       const referenceB = reference, ///
             referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
 
       if (referenceAEqualToReferenceB) {
         return true;
       }
-    });
+    }) || null;
 
-    context.trace(`Added the '${referenceString}' reference to the context.`);
+    if (referenceB !== null) {
+      context.trace(`The '${referenceString}' reference has already been added to the ephemeral context.`);
+    } else {
+      this.references.push(reference);
 
-    this.references.push(reference);
+      context.debug(`...added the '${referenceString}' reference to the ephemeral context.`);
+    }
+  }
+
+  addAssumption(assumption) {
+    const context = this, ///
+          assumptionA = assumption, ///
+          assumptionString = assumption.getString();
+
+    context.trace(`Adding the '${assumptionString}' assumption to the ephemeral context...`);
+
+    const assumptionB = this.assumptions.find((assumption) => {
+      const assumptionB = assumption, ///
+            assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+
+      if (assumptionAEqualToAssumptionB) {
+        return true;
+      }
+    }) || null;
+
+    if (assumptionB !== null) {
+      context.trace(`The '${assumptionString}' assumption has already been added to the ephemeral context.`);
+    } else {
+      this.assumptions.push(assumption);
+
+      context.debug(`...added the '${assumptionString}' assumption to the ephemeral context.`);
+    }
   }
 
   addSubstitution(substitution) {
@@ -142,23 +258,29 @@ export default class EphemeralContext extends Context {
           substitutionA = substitution, ///
           substitutionString = substitution.getString();
 
-    extract(this.substitutions, (substitution) => {
+    context.trace(`Adding the '${substitutionString}' substitution to the ephemeral context...`);
+
+    const substitutionB = this.substitutions.find((substitution) => {
       const substitutionB = substitution, ///
-            substitutionAEqualToAssertionB = substitutionA.isEqualTo(substitutionB);
+            substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
 
-      if (substitutionAEqualToAssertionB) {
+      if (substitutionAEqualToSubstitutionB) {
         return true;
       }
-    });
+    }) || null;
 
-    context.trace(`Added the '${substitutionString}' substitution to the context.`);
+    if (substitutionB !== null) {
+      context.trace(`The '${substitutionString}' substitution has already been added to the ephemeral context.`);
+    } else {
+      this.substitutions.push(substitution);
 
-    this.substitutions.push(substitution);
+      context.debug(`...added the '${substitutionString}' substitution to the ephemeral context.`);
+    }
   }
 
   findTermByTermNode(termNode) {
     const term = this.terms.find((term) => {
-      const termNodeMatches = term.matchNode(termNode);
+      const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -170,7 +292,7 @@ export default class EphemeralContext extends Context {
 
   findFrameByFrameNode(frameNode) {
     const frame = this.frames.find((frame) => {
-      const frameNodeMatches = frame.matchNode(frameNode);
+      const frameNodeMatches = frame.matchFrameNode(frameNode);
 
       if (frameNodeMatches) {
         return true;
@@ -180,9 +302,33 @@ export default class EphemeralContext extends Context {
     return frame;
   }
 
+  findJudgementByJudgementNode(judgementNode) {
+    const judgement = this.judgements.find((judgement) => {
+      const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);
+
+      if (judgementNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return judgement;
+  }
+
+  findEqualityByEqualityNode(equalityNode) {
+    const equality = this.equalities.find((equality) => {
+      const equalityNodeMatches = equality.matchEqualityNode(equalityNode);
+
+      if (equalityNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return equality;
+  }
+
   findStatementByStatementNode(statementNode) {
     const statement = this.statements.find((statement) => {
-      const statementNodeMatches = statement.matchNode(statementNode);
+      const statementNodeMatches = statement.matchStatementNode(statementNode);
 
       if (statementNodeMatches) {
         return true;
@@ -194,7 +340,7 @@ export default class EphemeralContext extends Context {
 
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
-      const assertionNodeMatches = assertion.matchNode(assertionNode);
+      const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
 
       if (assertionNodeMatches) {
         return true;
@@ -204,6 +350,18 @@ export default class EphemeralContext extends Context {
     return assertion;
   }
 
+  findAssumptionByAssumptionNode(assumptionNode) {
+    const assumption = this.assumptions.find((assumption) => {
+      const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
+
+      if (assumptionNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return assumption;
+  }
+
   findReferenceByMetavariableNode(metavariableNode) {
     const reference = this.references.find((reference) => {
       const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
@@ -218,7 +376,7 @@ export default class EphemeralContext extends Context {
 
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionNodeMatches = substitution.matchNode(substitutionNode);
+      const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
 
       if (substitutionNodeMatches) {
         return true;
@@ -229,73 +387,64 @@ export default class EphemeralContext extends Context {
   }
 
   isTermPresentByTermNode(termNode) {
-    const termPresent = this.terms.some((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    });
+    const term = this.findTermByTermNode(termNode),
+          termPresent = (term !== null);
 
     return termPresent;
   }
 
   isFramePresentByFrameNode(frameNode) {
-    const framePresent = this.frames.some((frame) => {
-      const frameNodeMatches = frame.matchFrameNode(frameNode);
-
-      if (frameNodeMatches) {
-        return true;
-      }
-    });
+    const frame = this.findFrameByFrameNode(frameNode),
+          framePresent = (frame !== null);
 
     return framePresent;
   }
 
-  isStatementPresentByStatementNode(statementNode) {
-    const statementPresent = this.statements.some((statement) => {
-      const statementNodeMatches = statement.matchStatementNode(statementNode);
+  isEqualityPresentByEqualityNode(equalityNode) {
+    const equality = this.findEqualityByEqualityNode(equalityNode),
+          equalityPresent = (equality !== null);
 
-      if (statementNodeMatches) {
-        return true;
-      }
-    });
+    return equalityPresent;
+  }
+
+  isJudgementPresentByJudgementNode(judgementNode) {
+    const judgement = this.findJudgementByJudgementNode(judgementNode),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
+
+  isStatementPresentByStatementNode(statementNode) {
+    const statement = this.findStatementByStatementNode(statementNode),
+          statementPresent = (statement !== null);
 
     return statementPresent;
   }
 
   isAssertionPresentByAssertionNode(assertionNode) {
-    const assertionPresent = this.assertions.some((assertion) => {
-      const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
-
-      if (assertionNodeMatches) {
-        return true;
-      }
-    });
+    const assertion = this.findAssertionByAssertionNode(assertionNode),
+          assertionPresent = (assertion !== null);
 
     return assertionPresent;
   }
 
-  isReferencePresentByReferenceNode(referenceNode) {
-    const referencePresent = this.references.some((reference) => {
-      const referenceNodeMatches = reference.matchReferenceNode(referenceNode);
+  isAssumptionPresentByAssumptionNode(assumptionNode) {
+    const assumption = this.findAssumptionByAssumptionNode(assumptionNode),
+          assumptionPresent = (assumption !== null);
 
-      if (referenceNodeMatches) {
-        return true;
-      }
-    });
+    return assumptionPresent;
+  }
+
+  isReferencePresentByMetavariableNode(metavariableNode) {
+    const reference = this.findReferenceByMetavariableNode(metavariableNode),
+          referencePresent = (reference !== null);
 
     return referencePresent;
   }
 
   isSubstitutionPresentBySubstitutionNode(substitutionNode) {
-    const substitutionPresent = this.substitutions.some((substitution) => {
-      const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
-
-      if (substitutionNodeMatches) {
-        return true;
-      }
-    });
+    const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode),
+          substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
   }
@@ -303,11 +452,14 @@ export default class EphemeralContext extends Context {
   static fromNothing(context) {
     const terms = [],
           frames = [],
+          judgements = [],
+          equalities = [],
           statements = [],
           assertions = [],
           references = [],
+          assumptions = [],
           substitutions = [],
-          emphemeralContext = new EphemeralContext(context, terms, frames, statements, assertions, references, substitutions);
+          emphemeralContext = new EphemeralContext(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions);
 
     return emphemeralContext;
   }