occam-verify-cli 1.0.428 → 1.0.436

package/src/element/frame.js

@@ -2,28 +2,20 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
 import { S, NOTHING } from "../constants";
-import { frameFromFrameNode } from "../utilities/element";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 
 const { first } = arrayUtilities;
 
-export default define(class Frame {
-  constructor(string, node, assumptions) {
-    this.string = string;
-    this.node = node;
-    this.assumptions = assumptions;
-  }
-
-  getString() {
-    return this.string;
-  }
+export default define(class Frame extends Element {
+  constructor(context, string, node, assumptions) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.assumptions = assumptions;
   }
 
   getAssumptions() {
@@ -74,14 +66,6 @@ export default define(class Frame {
 
   isSingular() { return this.node.isSingular(); }
 
-  isEqualTo(frame) {
-    const frameNode = frame.getNode(),
-          matches = this.node.match(frameNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   isMetavariableEqualToMetavariable(metavariable, context) {
     let metavariableEqualToMetavariable;
 
@@ -314,39 +298,4 @@ export default define(class Frame {
 
     return frame;
   }
-
-  static fromFrameNode(frameNode, context) { return frameFromFrameNode(frameNode, context); }
-
-  static fromJudgementNode(judgementNode, context) {
-    const frameNode = judgementNode.getFrameNode(),
-          frame = frameFromFrameNode(frameNode, context);
-
-    return frame;
-  }
-
-  static fromDefinedAssertionNode(definedAssertionNode, context) {
-    let frame = null;
-
-    const frameNode = definedAssertionNode.getFrameNode();
-
-    if (frameNode !== null) {
-      frame = frameFromFrameNode(frameNode, context);
-    }
-
-    return frame;
-  }
 });
-
-function assumptionsStringFromAssumptions(assumptions) {
-  const assumptionsString = assumptions.reduce((assumptionsString, assumption) => {
-    const assumptionString = assumption.getString();
-
-    assumptionsString = (assumptionsString === null) ?
-                           assumptionString :
-                            `${assumptionsString}, ${assumptionString}`;
-
-    return assumptionsString;
-  }, null);
-
-  return assumptionsString;
-}

package/src/element/hypothesis.js

@@ -1,24 +1,17 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
-export default define(class Hypothesis {
-  constructor(string, node, statement) {
-    this.string = string;
-    this.node = node;
-    this.statement = statement;
-  }
-
-  getString() {
-    return this.string;
-  }
+export default define(class Hypothesis extends Element {
+  constructor(context, string, node, statement) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.statement = statement;
   }
 
   getStatement() {
@@ -107,18 +100,8 @@ export default define(class Hypothesis {
     }
 
     const node = null,
-          hypothesis = new Hypothesis(string, node, statement);
+          hypothesis = new Hypothesis(context, string, node, statement);
 
     return hypothesis;
   }
-
-  static fromHypothesisNode(hypothesisNode, context) {
-    const { Statement } = elements,
-          node = hypothesisNode, ///
-          string = context.nodeAsString(node),
-          statement = Statement.fromHypothesisNode(hypothesisNode, context),
-          hypothesis = new Hypothesis(string, node, statement);
-
-    return hypothesis
-  }
 });

package/src/element/judgement.js

@@ -1,26 +1,19 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
-export default define(class Judgement {
-  constructor(string, node, frame, assumption) {
-    this.string = string;
-    this.node = node;
+export default define(class Judgement extends Element {
+  constructor(context, string, node, frame, assumption) {
+    super(context, string, node);
+
     this.frame = frame;
     this.assumption = assumption;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getFrame() {
     return this.frame;
   }
@@ -149,24 +142,6 @@ export default define(class Judgement {
   }
 
   static name = "Judgement";
-
-  static fromStatementNode(statementNode, context) {
-    let judgement = null;
-
-    const judgementNode = statementNode.getJudgementNode();
-
-    if (judgementNode !== null) {
-      const { Frame, Assumption } = elements,
-            node = judgementNode, ///
-            string = context.nodeAsString(node),
-            frame = Frame.fromJudgementNode(judgementNode, context),
-            assumption = Assumption.fromJudgementNode(judgementNode, context);
-
-      judgement = new Judgement(string, node, frame, assumption);
-    }
-
-    return judgement;
-  }
 });
 
 function referenceFromMetavariable(metavariable, context) {

package/src/element/label.js

@@ -1,26 +1,21 @@
 "use strict";
 
-import elements from "../elements";
+import Element from "../element";
 
 import { define } from "../elements";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-export default define(class Label {
-  constructor(context, metavariable) {
-    this.context = context;
-    this.metavariable = metavariable;
-  }
+export default define(class Label extends Element {
+  constructor(context, string, node, metavariable) {
+    super(context, string, node);
 
-  getContext() {
-    return this.context;
+    this.metavariable = metavariable;
   }
 
   getMetavariable() {
     return this.metavariable;
   }
 
-  getString() { return this.metavariable.getString(); }
-
   getMetavariableName() {
     const metavariableName = this.metavariable.getName();
 
@@ -91,15 +86,9 @@ export default define(class Label {
 
   static fromJSON(json, context) {
     const metavariable = metavariableFromJSON(json, context),
-          label = new Label(context, metavariable);
-
-    return label;
-  }
-
-  static fromLabelNode(labelNode, context) {
-    const { Metavariable } = elements,
-          metavariable = Metavariable.fromLabelNode(labelNode, context),
-          label = new Label(context, metavariable);
+          string = metavariable.getString(),
+          node = metavariable.getNode(),
+          label = new Label(context, string, node, metavariable);
 
     return label;
   }

package/src/element/lemma.js

@@ -33,11 +33,4 @@ export default define(class Lemma extends AxiomLemmaTheoremConjecture {
   }
 
   static name = "Lemma";
-
-  static fromLemmaNode(lemmaNode, context) {
-    const node = lemmaNode, ///
-          lemma = AxiomLemmaTheoremConjecture.fromNode(Lemma, node, context);
-
-    return lemma;
-  }
 });

package/src/element/metaLemma.js

@@ -31,11 +31,4 @@ export default define(class MetaLemma extends MetaLemmaMetatheorem {
   static name = "MetaLemma";
 
   static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(MetaLemma, json, context); }
-
-  static fromMetaLemmaNode(metaLemmaNode, context) {
-    const node = metaLemmaNode, ///
-          metaLemma = MetaLemmaMetatheorem.fromNode(MetaLemma, node, context);
-
-    return metaLemma;
-  }
 });

package/src/element/metaLemmaMetatheorem.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import LocalContext from "../context/local";
 
@@ -13,11 +14,10 @@ import { labelFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-export default class MetaLemmaMetatheorem {
+export default class MetaLemmaMetatheorem extends Element {
   constructor(context, string, node, label, suppositions, deduction, proof, substitutions) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
@@ -25,18 +25,6 @@ export default class MetaLemmaMetatheorem {
     this.substitutions = substitutions;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getLabel() {
     return this.label;
   }

package/src/element/metaType.js

@@ -1,21 +1,15 @@
 "use strict";
 
+import Element from "../element";
+
 import { define } from "../elements";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-class MetaType {
-  constructor(string, node, name) {
-    this.string = string;
-    this.node = node;
-    this.name = name;
-  }
-
-  getString() {
-    return this.string;
-  }
+class MetaType extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.name = name;
   }
 
   getName() {
@@ -52,34 +46,17 @@ class MetaType {
 
     return metaType;
   }
-
-  static fromMetaTypeNode(metaTypeNode, context) {
-    const metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
-
-    return metaType;
-  }
-
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-    const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
-          metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
-
-    return metaType;
-  }
-}
-
-function metaTypeFromMetaTypeNode(metaTypeNode, context) {
-  const metaTypeName = metaTypeNode.getMetaTypeName(),
-        metaType = metaTypeFromMetaTypeName(metaTypeName);
-
-  return metaType;
 }
 
 export default define(MetaType);
 
 class FrameMetaType extends MetaType {
   static fromNothing() {
-    const name = FRAME_META_TYPE_NAME,
-          frameMetaType = new FrameMetaType(name);
+    const context = null,
+          string = null,
+          node = null,
+          name = FRAME_META_TYPE_NAME,
+          frameMetaType = new FrameMetaType(context, string, node, name);
 
     return frameMetaType;
   }
@@ -87,8 +64,11 @@ class FrameMetaType extends MetaType {
 
 class ReferenceMetaType extends MetaType {
   static fromNothing() {
-    const name = REFERENCE_META_TYPE_NAME,
-          referenceMetaType = new ReferenceMetaType(name);
+    const context = null,
+          string = null,
+          node = null,
+          name = REFERENCE_META_TYPE_NAME,
+          referenceMetaType = new ReferenceMetaType(context, string, node, name);
 
     return referenceMetaType;
   }
@@ -96,39 +76,18 @@ class ReferenceMetaType extends MetaType {
 
 class StatementMetaType extends MetaType {
   static fromNothing() {
-    const name = STATEMENT_META_TYPE_NAME,
-          statementMetaType = new StatementMetaType(name);
+    const context = null,
+          string = null,
+          node = null,
+          name = STATEMENT_META_TYPE_NAME,
+          statementMetaType = new StatementMetaType(context, string, node, name);
 
     return statementMetaType;
   }
 }
 
 export const frameMetaType = FrameMetaType.fromNothing();
-export const referenceMetaType = ReferenceMetaType.fromNothing();
-export const statementMetaType = StatementMetaType.fromNothing();
-
-function metaTypeFromMetaTypeName(metaTypeName) {
-  let metaType;
-
-  switch (metaTypeName) {
-    case FRAME_META_TYPE_NAME: {
-      metaType = frameMetaType; ///
-
-      break;
-    }
 
-    case REFERENCE_META_TYPE_NAME: {
-      metaType = referenceMetaType; ///
-
-      break;
-    }
-
-    case STATEMENT_META_TYPE_NAME: {
-      metaType = statementMetaType; ///
-
-      break;
-    }
-  }
+export const referenceMetaType = ReferenceMetaType.fromNothing();
 
-  return metaType;
-}
+export const statementMetaType = StatementMetaType.fromNothing();

package/src/element/metatheorem.js

@@ -31,11 +31,4 @@ export default define(class Metatheorem extends MetaLemmaMetatheorem {
   static name = "Metatheorem";
 
   static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(Metatheorem, json, context); }
-
-  static fromMetatheoremNode(metatheoremNode, context) {
-    const node = metatheoremNode, ///
-          metatheorem = MetaLemmaMetatheorem.fromNode(Metatheorem, node, context);
-
-    return metatheorem;
-  }
 });

package/src/element/metavariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
@@ -9,23 +10,15 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
 
-export default define(class Metavariable {
-  constructor(string, node, name, type, metaType) {
-    this.string = string;
-    this.node = node;
+export default define(class Metavariable extends Element {
+  constructor(context, string, node, name, type, metaType) {
+    super(context, string, node);
+    
     this.name = name;
     this.type = type;
     this.metaType = metaType;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getName() {
     return this.name;
   }
@@ -62,14 +55,6 @@ export default define(class Metavariable {
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
-  isEqualTo(metavariable) {
-    const metavariableNode = metavariable.getNode(),
-          matches = this.node.match(metavariableNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   verify(context) {
     let verifies;
 
@@ -411,80 +396,7 @@ export default define(class Metavariable {
           node = metavariableNode,  ///
           type = typeFromJSON(json, context),
           metaType = metaTypeFromJSON(json, context),
-          metavariable = new Metavariable(string, node, name, type, metaType);
-
-    return metavariable;
-  }
-
-  static fromLabelNode(labelNode, context) {
-    const metavariableNode = labelNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromFrameNode(frameNode, context) {
-    let metavariable = null;
-
-    const singularMetavariableNode = frameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      const metavariableNode = singularMetavariableNode;  ///
-
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromReferenceNode(referenceNode, context) {
-    const metavariableNode = referenceNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromStatementNode(statementNode, context) {
-    let metavariable = null;
-
-    const singularMetavariableNode = statementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      const metavariableNode = singularMetavariableNode;  ///
-
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    const metavariableNode = assumptionNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromMetavariableNode(metavariableNode, context) {
-    let metavariable = null;
-
-    if (metavariableNode !== null) {
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-    const { MetaType } = elements,
-          metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
-          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-          metaType = MetaType.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    metavariable.setType(type);
-
-    metavariable.setMetaType(metaType);
+          metavariable = new Metavariable(context, string, node, name, type, metaType);
 
     return metavariable;
   }

package/src/element/parameter.js

@@ -1,22 +1,20 @@
 "use strict";
 
+import Element from "../element";
+
 import { define } from "../elements";
 
-export default define(class Parameter {
-  constructor(name) {
+export default define(class Parameter extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
+
     this.name = name;
   }
-
+  
   getName() {
     return this.name;
   }
 
-  getString() {
-    const string = this.name; ///
-
-    return string;
-  }
-
   findReplacementNode(substitutions) {
     let replacementNode = null;
 
@@ -49,15 +47,9 @@ export default define(class Parameter {
 
   static fromJSON(json, context) {
     const { name } = json,
-          parameter = new Parameter(name);
-
-    return parameter;
-  }
-
-  static fromParameterNode(parameterNode, context) {
-    const parameterName = parameterNode.getParameterName(),
-          name = parameterName, ///
-          parameter = new Parameter(name);
+          string = null,
+          node = null,
+          parameter = new Parameter(context, string, node, name);
 
     return parameter;
   }

package/src/element/premise.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
@@ -8,27 +9,14 @@ import { define } from "../elements";
 import { subproofAssertionFromStatement } from "../utilities/statement";
 import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
-export default define(class Premise {
+export default define(class Premise extends Element {
   constructor(context, string, node, statement, procedureCall) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getStatement() {
     return this.statement;
   }
@@ -277,19 +265,4 @@ export default define(class Premise {
 
     return premise;
   }
-
-  static fromPremiseNode(premiseNode, context) {
-    const { Statement, ProcedureCall } = elements,
-          node = premiseNode, ///
-          string = context.nodeAsString(node),
-          statement = Statement.fromPremiseNode(premiseNode, context),
-          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),
-          temporaryContext = null;
-
-    context = temporaryContext; ///
-
-    const premise = new Premise(context, string, node, statement, procedureCall);
-
-    return premise
-  }
 });