occam-verify-cli 1.0.871 → 1.0.872

package/src/context/mnemic.js

@@ -175,260 +175,110 @@ export default class MnemicContext extends Context {
 
   addTerm(term) {
     const context = this, ///
-          termA = term, ///
           termString = term.getString();
 
     context.trace(`Adding the '${termString}' term to the mnemic context...`);
 
-    const terms = this.getTerms(),
-          termB = terms.find((term) => {
-            const termB = term, ///
-                  termAComparesToTermB = termA.compareTerm(termB);
-      
-            if (termAComparesToTermB) {
-              return true;
-            }
-          }) || null;
-
-    if (termB !== null) {
-      context.trace(`The '${termString}' term has already been added to the mnemic context.`);
-    } else {
-      this.terms.push(term);
-    }
+    this.terms.push(term);
 
     context.debug(`...added the '${termString}' term to the mnemic context.`);
   }
 
   addFrame(frame) {
     const context = this, ///
-          frameA = frame, ///
           frameString = frame.getString();
 
     context.trace(`Adding the '${frameString}' frame to the mnemic context...`);
 
-    const frames = this.getFrames(),
-          frameB = 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 mnemic context.`);
-    } else {
-      this.frames.push(frame);
-    }
+    this.frames.push(frame);
 
     context.debug(`...added the '${frameString}' frame to the mnemic context.`);
   }
 
   addEquality(equality) {
     const context = this, ///
-          equalityA = equality, ///
           equalityString = equality.getString();
 
     context.trace(`Adding the '${equalityString}' equality to the mnemic context...`);
 
-    const equalities = this.getEqualities(),
-          equalityB = 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 mnemic context.`);
-    } else {
-      this.equalities.push(equality);
-    }
+    this.equalities.push(equality);
 
     context.debug(`...added the '${equalityString}' equality to the mnemic context.`);
   }
 
   addJudgement(judgement) {
     const context = this, ///
-          judgementA = judgement, ///
           judgementString = judgement.getString();
 
     context.trace(`Adding the '${judgementString}' judgement to the mnemic context...`);
 
-    const judgements = this.getJudgements(),
-          judgementB = judgements.find((judgement) => {
-            const judgementB = judgement, ///
-                  judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);
-      
-            if (judgementAEqualToEqualityB) {
-              return true;
-            }
-          }) || null;
-
-    if (judgementB !== null) {
-      context.trace(`The '${judgementString}' judgement has already been added to the mnemic context.`);
-    } else {
-      this.judgements.push(judgement);
-    }
+    this.judgements.push(judgement);
 
     context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);
   }
 
   addStatement(statement) {
     const context = this, ///
-          statementA = statement, ///
           statementString = statement.getString();
 
     context.trace(`Adding the '${statementString}' statement to the mnemic context...`);
 
-    const statements = this.getStatements(),
-          statementB = statements.find((statement) => {
-            const statementB = statement, ///
-                  statementAEqualToStatementB = statementA.isEqualTo(statementB);
-      
-            if (statementAEqualToStatementB) {
-              return true;
-            }
-          }) || null;
-
-    if (statementB !== null) {
-      context.trace(`The '${statementString}' statement has already been added to the mnemic context.`);
-    } else {
-      this.statements.push(statement);
-    }
+    this.statements.push(statement);
 
     context.debug(`...added the '${statementString}' statement to the mnemic context.`);
   }
 
   addAssertion(assertion) {
     const context = this, ///
-          assertionA = assertion, ///
           assertionString = assertion.getString();
 
     context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
 
-    const assertions = this.getAssumptions(),
-          assertionB = assertions.find((assertion) => {
-            const assertionB = assertion, ///
-                  assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
-      
-            if (assertionAEqualToAssertionB) {
-              return true;
-            }
-          }) || null;
-
-    if (assertionB !== null) {
-      context.trace(`The '${assertionString}' assertion has already been added to the mnemic context.`);
-    } else {
-      this.assertions.push(assertion);
-    }
+    this.assertions.push(assertion);
 
     context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
   }
 
   addReference(reference) {
     const context = this, ///
-          referenceA = reference, ///
           referenceString = reference.getString();
 
     context.trace(`Adding the '${referenceString}' reference to the mnemic context...`);
 
-    const references = this.getReferences(),
-          referenceB = references.find((reference) => {
-            const referenceB = reference, ///
-                  referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
-      
-            if (referenceAEqualToReferenceB) {
-              return true;
-            }
-          }) || null;
-
-    if (referenceB !== null) {
-      context.trace(`The '${referenceString}' reference has already been added to the mnemic context.`);
-    } else {
-      this.references.push(reference);
-    }
+    this.references.push(reference);
 
     context.debug(`...added the '${referenceString}' reference to the mnemic context.`);
   }
 
   addAssumption(assumption) {
     const context = this, ///
-          assumptionA = assumption, ///
           assumptionString = assumption.getString();
 
     context.trace(`Adding the '${assumptionString}' assumption to the mnemic context...`);
 
-    const assumptions = this.getAssumptions(),
-          assumptionB = 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 mnemic context.`);
-    } else {
-      this.assumptions.push(assumption);
-    }
+    this.assumptions.push(assumption);
 
     context.debug(`...added the '${assumptionString}' assumption to the mnemic context.`);
   }
 
   addMetavariable(metavariable) {
     const context = this, ///
-          metavariableA = metavariable, ///
           metavariableString = metavariable.getString();
 
     context.trace(`Adding the '${metavariableString}' metavariable to the mnemic context...`);
 
-    const metavariables = this.getMetavariables(),
-          metavariableB = metavariables.find((metavariable) => {
-            const metavariableB = metavariable, ///
-                  metavariableAEqualToSubstitutionB = metavariableA.isEqualTo(metavariableB);
-      
-            if (metavariableAEqualToSubstitutionB) {
-              return true;
-            }
-          }) || null;
-
-    if (metavariableB !== null) {
-      context.trace(`The '${metavariableString}' metavariable has already been added to the mnemic context.`);
-    } else {
-      this.metavariables.push(metavariable);
-    }
+    this.metavariables.push(metavariable);
 
     context.debug(`...added the '${metavariableString}' metavariable to the mnemic context.`);
   }
 
   addSubstitution(substitution) {
     const context = this, ///
-          substitutionA = substitution, ///
           substitutionString = substitution.getString();
 
     context.trace(`Adding the '${substitutionString}' substitution to the mnemic context...`);
 
-    const substitutions = this.getSubstitutions(),
-          substitutionB = substitutions.find((substitution) => {
-            const substitutionB = substitution, ///
-                  substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-            if (substitutionAEqualToSubstitutionB) {
-              return true;
-            }
-          }) || null;
-
-    if (substitutionB !== null) {
-      context.trace(`The '${substitutionString}' substitution has already been added to the mnemic context.`);
-    } else {
-      this.substitutions.push(substitution);
-    }
+    this.substitutions.push(substitution);
 
     context.debug(`...added the '${substitutionString}' substitution to the mnemic context.`);
   }

package/src/element/assumption.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
+import {instantiate, reconcile} from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
 
 export default define(class Assumption extends Element {
@@ -209,11 +209,13 @@ export default define(class Assumption extends Element {
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
 
-    topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+    reconcile((context) => {
+      topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-    if (topLevelMetaAssertionUnifies) {
-      topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-    }
+      if (topLevelMetaAssertionUnifies) {
+        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+      }
+    }, context);
 
     if (topLevelMetaAssertionUnifies) {
       context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);

package/src/element/reference.js

@@ -274,18 +274,13 @@ export default define(class Reference extends Element {
     const label = topLevelMetaAssertion.getLabel(),
           labelContext = label.getContext(),
           referenceString = this.getString(), ///
-          temporaryContext = context, ///
+          referenceContext = this.getContext(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
-    const specificContext = labelContext; ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = temporaryContext; ///
+    const generalContext = referenceContext, ///
+          specificContext = labelContext; ///
 
     join((specificContext) => {
       reconcile((specificContext) => {

package/src/element/substitution/frame.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { ablate, ablates, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablate, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class FrameSubstitution extends Substitution {
   constructor(contexts, string, node, lineIndex, targetFrame, replacementFrame) {
@@ -208,15 +208,18 @@ export default define(class FrameSubstitution extends Substitution {
     return frameSubstitutionn;
   }
 
-  static fromStatement(statement, generalContext, specificContext) {
+  static fromStatement(statement, context) {
     let frameSubstitution = null;
 
     const frameSubstitutionNode = statement.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      ablates((generalContext, specificContext) => {
+      ablate((context) => {
+        const generalContext = context, ///
+              specificContext = context;  ///
+
         frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
-      }, generalContext, specificContext);
+      }, context);
     }
 
     return frameSubstitution;

package/src/element/substitution/term.js

@@ -7,7 +7,7 @@ import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
-import { ablate, ablates, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablate, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, lineIndex, targetTerm, replacementTerm) {
@@ -219,15 +219,18 @@ export default define(class TermSubstitution extends Substitution {
     return termSubstitutionn;
   }
 
-  static fromStatement(statement, generalContext, specificContext) {
+  static fromStatement(statement, context) {
     let termSubstitution = null;
 
     const termSubstitutionNode = statement.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      ablates((generalContext, specificContext) => {
+      ablate((context) => {
+        const generalContext = context, ///
+              specificContext = context;  ///
+
         termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, generalContext, specificContext);
-      }, generalContext, specificContext);
+      }, context);
     }
 
     return termSubstitution;

package/src/utilities/context.js

@@ -141,24 +141,8 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export function ablates(innerFunction, ...contexts) {
-  contexts = contexts.map((context) => {  ///
-    let contextNominalFileContext = (context instanceof NominalFileContext);
-
-    while (!contextNominalFileContext) {
-      context = context.getContext();
-
-      contextNominalFileContext = (context instanceof NominalFileContext);
-    }
-
-    return context;
-  });
-
-  return innerFunction(...contexts);
-}
-
 export function attempts(innerFunction, ...contexts) {
-  contexts = contexts.map((context) => {
+  contexts = contexts.map((context) => {  ///
     const mnemicContext = MenmicContext.fromNothing(context);
 
     context = mnemicContext;  ///

package/src/utilities/json.js

@@ -772,9 +772,13 @@ export function termToTermJSON(term) {
 }
 
 export function typeToTypeJSON(type) {
-  const typeJSON = (type !== null) ?
-                     type.toJSON() :
-                       null;
+  let typeJSON = null;
+
+  if (type !== null) {
+    const abridged = true;
+
+    typeJSON = type.toJSON(abridged);
+  }
 
   return typeJSON;
 }
@@ -1008,9 +1012,9 @@ export function hypothesesToHypothesesJSON(hypotheses) {
 }
 
 export function superTypesToSuperTypesJSON(superTypes) {
-  const abridged = true,
-        superTypesJSON = superTypes.map((superType) => {
-          const superTypeJSON = superType.toJSON(abridged);
+  const superTypesJSON = superTypes.map((superType) => {
+          const abridged = true,
+                superTypeJSON = superType.toJSON(abridged);
 
           return superTypeJSON;
         });

package/src/utilities/validation.js

@@ -104,10 +104,8 @@ function validateStatementAsMetavariable(statement, context) {
 
       let substitution;
 
-      const generalContext = context, ///
-            specificContext = context,  ///
-            termSubstitution = TermSubstitution.fromStatement(statement, generalContext, specificContext),
-            frameSubstitution = FrameSubstitution.fromStatement(statement, generalContext, specificContext);
+      const termSubstitution = TermSubstitution.fromStatement(statement, context),
+            frameSubstitution = FrameSubstitution.fromStatement(statement, context);
 
       substitution = (termSubstitution || frameSubstitution);