occam-verify-cli 0.0.1111 → 0.0.1112

package/src/dom/conclusion.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export  default domAssigned(class Conclusion {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const conclusion = this,  ///
+          statementString = statement.getString(),
+          conclusionString = conclusion.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+    }
+
+    return statementUnified;
+  }
+
+  verify(context) {
+    let verified = false;
+
+    const conclusionString = this.string;  ///
+
+    if (this.statement !== null) {
+      context.trace(`Verifying the '${conclusionString}' conclusion...`);
+
+      const stated = true,
+            assignments = null,
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      verified = statementVerified; ///
+
+      if (verified) {
+        context.debug(`...verified the '${conclusionString}' conclusion.`);
+      }
+    } else {
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static name = "Conclusion";
+
+  static fromJSON(json, fileContext) {
+    const statement = statementFromJSON(json, fileContext),
+          string = statement.getString(),
+          conclusion = new Conclusion(string, statement);
+
+    return conclusion;
+  }
+
+  static fromConclusionNode(conclusionNode, fileContext) {
+    const { Statement } = dom,
+          statement = Statement.fromConclusionNode(conclusionNode, fileContext),
+          statementString = statement.getString(),
+          string = statementString, ///
+          conclusion = new Conclusion(string, statement);
+
+    return conclusion;
+  }
+});

package/src/{conjecture.js → dom/conjecture.js}

@@ -1,9 +1,10 @@
 "use strict";
 
-import shim from "./shim";
 import TopLevelAssertion from "./topLevelAssertion";
 
-class Conjecture extends TopLevelAssertion {
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Conjecture extends TopLevelAssertion {
   verify() {
     let verified;
 
@@ -26,13 +27,9 @@ class Conjecture extends TopLevelAssertion {
     return verified;
   }
 
+  static name = "Conjecture";
+
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Conjecture, json, fileContext); }
 
   static fromConjectureNode(conjectureNode, fileContext) { return TopLevelAssertion.fromNode(Conjecture, conjectureNode, fileContext); }
-}
-
-Object.assign(shim, {
-  Conjecture
 });
-
-export default Conjecture;

package/src/dom/consequent.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default domAssigned(class Consequent {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const consequent = this,  ///
+          statementString = statement.getString(),
+          consequentString = consequent.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
+    }
+
+    return statementUnified;
+  }
+
+  verify(context) {
+    let verified = false;
+
+    const consequentString = this.string;  ///
+
+    if (this.statement !== null) {
+      context.trace(`Verifying the '${consequentString}' consequent...`);
+
+      const stated = true,
+            assignments = null,
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      verified = statementVerified; ///
+
+      if (verified) {
+        context.debug(`...verified the '${consequentString}' consequent.`);
+      }
+    } else {
+      context.debug(`Unable to verify the '${consequentString}' consequent because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static name = "Consequent";
+
+  static fromJSON(json, fileContext) {
+    const statement = statementFromJSON(json, fileContext),
+          string = statement.getString(),
+          consequent = new Consequent(string, statement);
+
+    return consequent;
+  }
+
+  static fromConsequentNode(consequentNode, fileContext) {
+    const { Statement } = dom,
+          statement = Statement.fromConsequentNode(consequentNode, fileContext),
+          statementString = statement.getString(),
+          string = statementString, ///
+          consequent = new Consequent(string, statement);
+
+    return consequent;
+  }
+});

package/src/{declaration → dom/declaration}/combinator.js

@@ -1,8 +1,10 @@
 "use strict";
 
-import shim from "../shim";
+import Combinator from "../../combinator";
 
-export default class CombinatorDeclaration {
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class CombinatorDeclaration {
   constructor(fileContext, combinator) {
     this.fileContext = fileContext;
     this.combinator = combinator;
@@ -40,11 +42,12 @@ export default class CombinatorDeclaration {
     return verified;
   }
 
+  static name = "CombinatorDeclaration";
+
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
-    const { Combinator } = shim,
-          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+    const combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
           combinatorDeclaration = new CombinatorDeclaration(fileContext, combinator);
 
     return combinatorDeclaration;
   }
-}
+});

package/src/{declaration → dom/declaration}/constructor.js

@@ -1,8 +1,10 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../../dom";
 
-export default class ConstructorDeclaration {
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class ConstructorDeclaration {
   constructor(fileContext, constructor) {
     this.fileContext = fileContext;
     this.constructor = constructor;
@@ -40,11 +42,13 @@ export default class ConstructorDeclaration {
     return verified;
   }
 
+  static name = "ConstructorDeclaration";
+
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const { Constructor } = shim,
+    const { Constructor } = dom,
           constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
           constructorDeclaration = new ConstructorDeclaration(fileContext, constructor);
 
     return constructorDeclaration;
   }
-}
+});

package/src/{declaration → dom/declaration}/metavariable.js

@@ -1,12 +1,13 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../../dom";
 
-import { nodeQuery } from "../utilities/query";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
 
 const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
 
-export default class MetavariableDeclaration {
+export default domAssigned(class MetavariableDeclaration {
   constructor(fileContext, string, metavariable) {
     this.fileContext = fileContext;
     this.string = string;
@@ -47,8 +48,10 @@ export default class MetavariableDeclaration {
     return verified;
   }
 
+  static name = "MetavariableDeclaration";
+
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const { MetaType, Metavariable } = shim,
+    const { MetaType, Metavariable } = dom,
           metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext),
           metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
@@ -57,7 +60,7 @@ export default class MetavariableDeclaration {
 
     return metavariableDeclaration;
   }
-}
+});
 
 function stringFromMetavariableAndMetaType(metavariable, metaType) {
   let string;

package/src/{declaration → dom/declaration}/type.js

@@ -1,8 +1,10 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../../dom";
 
-export default class TypeDeclaration {
+import { domAssigned } from "../../dom";
+
+export default domAssigned(class TypeDeclaration {
   constructor(fileContext, type) {
     this.fileContext = fileContext;
     this.type = type;
@@ -40,11 +42,13 @@ export default class TypeDeclaration {
     return verified;
   }
 
+  static name = "TypeDeclaration";
+
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-    const { Type } = shim,
+    const { Type } = dom,
           type = Type.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
           typeDeclaration = new TypeDeclaration(fileContext, type);
 
     return typeDeclaration;
   }
-}
+});

package/src/{declaration → dom/declaration}/variable.js

@@ -1,13 +1,14 @@
 "use strict";
 
-import shim from "../shim";
+import dom from "../../dom";
 
-import { nodeQuery } from "../utilities/query";
-import { typeNameFromTypeNode } from "../utilities/name";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+import { typeNameFromTypeNode } from "../../utilities/name";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type");
 
-export default class VariableDeclaration {
+export default domAssigned(class VariableDeclaration {
   constructor(fileContext, string, variable) {
     this.fileContext = fileContext;
     this.string = string;
@@ -48,8 +49,10 @@ export default class VariableDeclaration {
     return verified;
   }
 
+  static name = "VariableDeclaration";
+
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const { Variable } = shim,
+    const { Variable } = dom,
           typeNode = typeNodeQuery(variableDeclarationNode),
           variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
           string = stringFromVariableAndTypeNode(variable, typeNode),
@@ -57,7 +60,7 @@ export default class VariableDeclaration {
 
     return variableDeclaration;
   }
-}
+});
 
 function stringFromVariableAndTypeNode(variable, typeNode) {
   let string;

package/src/{declaration.js → dom/declaration.js}

@@ -1,16 +1,15 @@
 "use strict";
 
-import shim from "./shim";
-import Reference from "./reference";
-import LocalContext from "./context/local";
+import dom from "../dom";
 
-import { nodeQuery } from "./utilities/query";
-import { stripBracketsFromStatementNode } from "./utilities/brackets";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { stripBracketsFromStatementNode } from "../utilities/brackets";
 
 const referenceNodeQuery = nodeQuery("/declaration/reference"),
       statementNodeQuery = nodeQuery("/declaration/statement");
 
-class Declaration {
+export default domAssigned(class Declaration {
   constructor(string, reference, statement) {
     this.string = string;
     this.reference = reference;
@@ -102,8 +101,7 @@ class Declaration {
 
     context.trace(`Unifying the '${metalemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           referenceUnified = metaLemmaMetatheorem.unifyReference(this.reference, substitutions, context);
 
     if (referenceUnified) {
@@ -297,18 +295,21 @@ class Declaration {
     return verifiedWhenDerived;
   }
 
+  static name = "Declaration";
+
   static fromDeclarationNode(declarationNode, context) {
     let declaration = null;
 
     if (declarationNode !== null) {
-      const { Statement } = shim,
+      const { Statement } = dom,
             referenceNode = referenceNodeQuery(declarationNode);
 
       let statementNode = statementNodeQuery(declarationNode);
 
       statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
-      const reference = Reference.fromReferenceNode(referenceNode, context),
+      const { Reference } = dom,
+            reference = Reference.fromReferenceNode(referenceNode, context),
             statement = Statement.fromStatementNode(statementNode, context),
             node = declarationNode,  ///
             string = context.nodeAsString(node);
@@ -318,10 +319,4 @@ class Declaration {
 
     return declaration;
   }
-}
-
-Object.assign(shim, {
-  Declaration
 });
-
-export default Declaration;

package/src/{derivation.js → dom/derivation.js}

@@ -2,15 +2,16 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
+import dom from "../dom";
 
-import { nodesQuery } from "./utilities/query";
+import { nodesQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
 
 const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-class Derivation {
+export default domAssigned(class Derivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -29,9 +30,9 @@ class Derivation {
     let verified;
 
     verified = this.proofSteps.every((proofStep) => { ///
-      const proofStepVerified = proofStep.verify(substitutions, context);
+      const proofStepVerifiedAndUnified = proofStep.verifyAndUnify(substitutions, context);
 
-      if (proofStepVerified) {
+      if (proofStepVerifiedAndUnified) {
         return true;
       }
     });
@@ -39,8 +40,10 @@ class Derivation {
     return verified;
   }
 
+  static name = "Derivation";
+
   static fromDerivationNode(derivationNode, fileContext) {
-    const { ProofStep } = shim,
+    const { ProofStep } = dom,
           proofStepNodes = proofStepNodesQuery(derivationNode),
           proofSteps = proofStepNodes.map((proofStepNode) => {
             const proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
@@ -51,10 +54,4 @@ class Derivation {
 
     return derivation;
   }
-}
-
-Object.assign(shim, {
-  Derivation
 });
-
-export default Derivation;

package/src/{equality.js → dom/equality.js}

@@ -1,18 +1,19 @@
 "use strict";
 
-import shim from "./shim";
-import EqualityAssignment from "./assignment/equality";
-import VariableAssignment from "./assignment/variable";
+import dom from "../dom";
+import EqualityAssignment from "../assignment/equality";
+import VariableAssignment from "../assignment/variable";
 
-import { nodeQuery } from "./utilities/query";
-import { unifyEquality } from "./utilities/unification";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { unifyEquality } from "../utilities/unification";
 
 const equalityNodeQuery = nodeQuery("/statement/equality"),
       variableNodeQuery = nodeQuery("/term/variable!"),
       leftTermNodeQuery = nodeQuery("/equality/term[0]"),
       rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
-class Equality {
+export default domAssigned(class Equality {
   constructor(string,leftTerm, rightTerm) {
     this.string = string;
     this.leftTerm = leftTerm;
@@ -87,7 +88,7 @@ class Equality {
 
       if (verifiedWhenStated || verifiedWhenDerived) {
         if (assignments !== null) {
-          const { Variable } = shim,
+          const { Variable } = dom,
                 type = this.getType(),
                 leftTermNode = this.leftTerm.getNode(),
                 rightTermNode = this.rightTerm.getNode(),
@@ -203,13 +204,15 @@ class Equality {
     return verifiedWhenDerived;
   }
 
+  static name = "Equality";
+
   static fromStatementNode(statementNode, context) {
     let equality = null;
 
     const equalityNode = equalityNodeQuery(statementNode);
 
     if (equalityNode !== null) {
-      const { Term } = shim,
+      const { Term } = dom,
             leftTermNode = leftTermNodeQuery(equalityNode),
             rightTermNode = rightTermNodeQuery(equalityNode),
             leftTerm = Term.fromTermNode(leftTermNode, context),
@@ -222,10 +225,4 @@ class Equality {
 
     return equality;
   }
-}
-
-Object.assign(shim, {
-  Equality
 });
-
-export default Equality;

package/src/{error.js → dom/error.js}

@@ -1,6 +1,8 @@
 "use strict";
 
-export default class Error {
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Error {
   constructor(fileContext, string) {
     this.fileContext = fileContext;
     this.string = string;
@@ -24,6 +26,8 @@ export default class Error {
     return verified;
   }
 
+  static name = "Error";
+
   static fromErrorNode(errorNode, fileContext) {
     const node = errorNode, ///
           string = fileContext.nodeAsString(node),
@@ -31,5 +35,4 @@ export default class Error {
 
     return error;
   }
-}
-
+});

package/src/{frame.js → dom/frame.js}

@@ -2,10 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
+import dom from "../dom";
 
-import { FRAME_META_TYPE_NAME } from "./metaTypeNames";
-import { nodeQuery, nodesQuery } from "./utilities/query";
+import { domAssigned } from "../dom";
+import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const frameNodeQuery = nodeQuery("/*/frame"),
       declarationNodesQuery = nodesQuery("/frame/declaration"),
@@ -14,7 +15,7 @@ const frameNodeQuery = nodeQuery("/*/frame"),
 
 const { first } = arrayUtilities;
 
-class Frame {
+export default domAssigned(class Frame {
   constructor(string, node, tokens, declarations, metavariables) {
     this.string = string;
     this.node = node;
@@ -62,13 +63,8 @@ class Frame {
   }
 
   isEqualTo(frame) {
-    let equalTo = false;
-
-    if (frame !== null) {
-      const frameString = frame.getString();
-
-      equalTo = (frameString === this.string);
-    }
+    const frameString = frame.getString(),
+          equalTo = (frameString === this.string);
 
     return equalTo;
   }
@@ -204,10 +200,9 @@ class Frame {
 
     assignments = null; ///
 
-    const frame = null; ///
-
     const declarationsVerified = declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(frame, assignments, stated, context);
+      const frame = null, ///
+            declarationVerified = declaration.verify(frame, assignments, stated, context);
 
       return declarationVerified;
     });
@@ -282,11 +277,13 @@ class Frame {
     return verifiedGivenMetaType;
   }
 
+  static name = "Frame";
+
   static fromFrameNode(frameNode, context) {
     let frame = null;
 
     if (frameNode !== null) {
-      const { Declaration, Metavariable } = shim,
+      const { Declaration, Metavariable } = dom,
             node = frameNode, ///
             string = context.nodeAsString(node),
             tokens = context.nodeAsTokens(node),
@@ -318,7 +315,7 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const { Metavariable } = shim,
+        const { Metavariable } = dom,
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               declarations = [],
               metavariables = [
@@ -344,7 +341,7 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const { Metavariable } = shim,
+        const { Metavariable } = dom,
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               declarations = [],
               metavariables = [
@@ -360,10 +357,4 @@ class Frame {
 
     return frame;
   }
-}
-
-Object.assign(shim, {
-  Frame
 });
-
-export default Frame;