occam-verify-cli 1.0.428 → 1.0.436

package/src/element/statement/combinator/bracketed.js

@@ -2,9 +2,8 @@
 
 import CombinatorStatement from "../../statement/combinator";
 
-import { define } from "../../elements";
-import { statementFromStatementNode } from "../../utilities/element";
-import { bracketedCombinatorStatementString, instantiateBracketedCombinatorStatement } from "../../../process/instantiate";
+import { define } from "../../../elements";
+import { bracketedCombinatorStatementFromNothing } from "../../../utilities/instance";
 
 export default define(class BracketedCombinatorStatement extends CombinatorStatement {
   unifyStatement(statement, assignments, stated, context) {
@@ -26,12 +25,7 @@ export default define(class BracketedCombinatorStatement extends CombinatorState
   static name = "BracketedCombinatorStatement";
 
   static fromNothing() {
-    const bracketedCombinatorStatementNode = instantiateBracketedCombinatorStatement(),
-          nodeAsString = () => bracketedCombinatorStatementString,
-          context = {
-            nodeAsString
-          },
-          bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+    const bracketedCombinatorStatement = bracketedCombinatorStatementFromNothing();
 
     return bracketedCombinatorStatement;
   }

package/src/element/statement.js

@@ -2,33 +2,19 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import verifyMixins from "../mixins/statement/verify";
 
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { stripBracketsFromStatementNode } from "../utilities/brackets";
 
 const { match, backwardsSome } = arrayUtilities;
 
-export default define(class Statement {
+export default define(class Statement extends Element {
   constructor(context, string, node) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
+    super(context, string, node);
   }
 
   getMetavariableName() {
@@ -45,14 +31,6 @@ export default define(class Statement {
 
   isSingular() { return this.node.isSingular(); }
 
-  isEqualTo(statement) {
-    const statementNode = statement.getNode(),
-          matches = this.node.match(statementNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   isTermContained(term, context) {
     let termContained;
 
@@ -300,105 +278,4 @@ export default define(class Statement {
 
     return statement;
   }
-
-  static fromStepNode(stepNode, context) {
-    let statement = null;
-
-    const statementNode = stepNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromPremiseNode(premiseNode, context) {
-    let statement = null;
-
-    const statementNode = premiseNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromStatementNode(statementNode, context) {
-    const statement = statementFromStatementNode(statementNode, context);
-
-    return statement;
-  }
-
-  static fromDeductionNode(deductionNode, context) {
-    let statement = null;
-
-    const statementNode = deductionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromHypothesisNode(hypothesisNode, context) {
-    let statement = null;
-
-    const statementNode = hypothesisNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromConclusionNode(conclusionNode, context) {
-    let statement = null;
-
-    const statementNode = conclusionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    let statement = null;
-
-    let statementNode;
-
-    statementNode = assumptionNode.getStatementNode(); ///
-
-    if (statementNode !== null) {
-      statementNode = stripBracketsFromStatementNode(statementNode);  ///
-
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromSuppositionNode(suppositionNode, context) {
-    let statement = null;
-
-    const statementNode = suppositionNode.getStatementNode();
-
-    if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, context);
-    }
-
-    return statement;
-  }
-
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
-    const statementNode = combinatorDeclarationNode.getStatementNode(),
-          statement = statementFromStatementNode(statementNode, context);
-
-    return statement;
-  }
 });

package/src/element/step.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import unifyMixins from "../mixins/step/unify";
 import TemporaryContext from "../context/temporary";
@@ -8,28 +9,15 @@ import { define } from "../elements";
 import { equateStatements } from "../process/equate";
 import { propertyAssertionFromStatement } from "../utilities/statement";
 
-export default define(class Step {
+export default define(class Step extends Element {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getStatement() {
     return this.statement;
   }

package/src/element/subDerivation.js

@@ -2,15 +2,17 @@
 
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
+import Element from "../element";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
 
 const { last } = arrayUtilities;
 
-export default define(class SubDerivation {
-  constructor(stepsOrSubproofs) {
+export default define(class SubDerivation extends Element {
+  constructor(context, string, node, stepsOrSubproofs) {
+    super(context, string, node);
+
     this.stepsOrSubproofs = stepsOrSubproofs;
   }
 

package/src/element/subproof.js

@@ -1,26 +1,19 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import LocalContext from "../context/local";
 
 import { define } from "../elements";
 
-export default define(class Subproof {
-  constructor(string, node, suppositions, subDerivation) {
-    this.string = string;
-    this.node = node;
+export default define(class Subproof extends Element {
+  constructor(context, string, node, suppositions, subDerivation) {
+    super(context, string, node);
+
     this.suppositions = suppositions;
     this.subDerivation = subDerivation;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getSuppositions() {
     return this.suppositions;
   }

package/src/element/substitution.js

@@ -1,22 +1,10 @@
 "use strict";
 
-export default class Substitution {
-  constructor(context, string, node) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
+import Element from "../element";
 
-  getNode() {
-    return this.node;
+export default class Substitution extends Element {
+  constructor(context, string, node) {
+    super(context, string, node);
   }
 
   getTerm() {
@@ -86,14 +74,6 @@ export default class Substitution {
     return trivial;
   }
 
-  isEqualTo(substitution) {
-    const substitutionNode = substitution.getNode(),
-          matches = this.node.match(substitutionNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   isTermEqualToTerm(term, context) {
     const termEqualToTerm = false;
 

package/src/element/substitutions.js

@@ -2,13 +2,17 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
+
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
-export default define(class Substitutions {
-  constructor(array, savedArray) {
+export default define(class Substitutions extends Element {
+  constructor(context, string, node, array, savedArray) {
+    super(context, string, node);
+
     this.array = array;
     this.savedArray = savedArray;
   }

package/src/element/supposition.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 Supposition {
+export default define(class Supposition 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;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getStatement() {
     return this.statement;
   }
@@ -300,19 +288,4 @@ export default define(class Supposition {
 
     return supposition;
   }
-
-  static fromSuppositionNode(suppositionNode, context) {
-    const { Statement, ProcedureCall } = elements,
-          node = suppositionNode, ///
-          string = context.nodeAsString(node),
-          statement = Statement.fromSuppositionNode(suppositionNode, context),
-          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, context),
-          temporaryContext = null;
-
-    context = temporaryContext; ///
-
-    const supposition = new Supposition(context, string, node, statement, procedureCall);
-
-    return supposition
-  }
 });

package/src/element/term/constructor/bracketed.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import elements from "../../elements";
+import elements from "../../../elements";
 import Constructor from "../constructor";
 
-import { define } from "../../elements";
-import { bracketedConstructorTermString, instantiateBracketedConstructorTerm } from "../../../process/instantiate";
+import { define } from "../../../elements";
+import { bracketedConstructorTermFromNothing } from "../../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -55,12 +55,7 @@ export default define(class BracketedConstructor extends Constructor {
   static name = "BracketedConstructor";
 
   static fromNothing() {
-    const bracketedConstructorTermNode = instantiateBracketedConstructorTerm(),
-          nodeAsString = () => bracketedConstructorTermString,
-          context = {
-            nodeAsString
-          },
-          bracketedConstructorTerm = statementFromTermNode(bracketedConstructorTermNode, context);
+    const bracketedConstructorTerm = bracketedConstructorTermFromNothing();
 
     return bracketedConstructorTerm;
   }

package/src/element/term.js

@@ -2,29 +2,20 @@
 
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
+import Element from "../element";
 import verifyMixins from "../mixins/term/verify";
 
 import { define } from "../elements";
 import { instantiateTerm } from "../process/instantiate";
-import { termFromTermNode } from "../utilities/node.old";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
 
-export default define(class Term {
-  constructor(string, node, type) {
-    this.string = string;
-    this.node = node;
-    this.type = type;
-  }
-
-  getString() {
-    return this.string;
-  }
+export default define(class Term extends Element {
+  constructor(context, string, node, type) {
+    super(context, string, node);
 
-  getNode() {
-    return this.node;
+    this.type = type;
   }
 
   getType() {
@@ -180,51 +171,7 @@ export default define(class Term {
           termNode = instantiateTerm(string, context),
           node = termNode,  ///
           type = typeFromJSON(json, context),
-          term = new Term(string, node, type);
-
-    return term;
-  }
-
-  static fromTermNode(termNode, context) {
-    const term = termFromTermNode(termNode, context);
-
-    return term;
-  }
-
-  static fromTermNodeAndType(termNode, type, context) {
-    const node = termNode,  ///
-          string = context.nodeAsString(node),
-          term = new Term(string, node, type);
-
-    return term;
-  }
-
-  static fromDefinedAssertionNode(definedAssertionNode, context) {
-    let term = null;
-
-    const termNode = definedAssertionNode.getTermNode();
-
-    if (termNode !== null) {
-      term = termFromTermNode(termNode, context);
-    }
-
-    return term;
-  }
-
-  static fromPropertyRelationNode(propertyRelationNode, context) {
-    const termNode = propertyRelationNode.getTermNode(),
-          term = termFromTermNode(termNode, context);
-
-    return term;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Type } = elements,
-          termNode = constructorDeclarationNode.getTermNode(),
-          term = termFromTermNode(termNode, context),
-          type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
-
-    term.setType(type);
+          term = new Term(context, string, node, type);
 
     return term;
   }

package/src/element/theorem.js

@@ -30,11 +30,4 @@ export default define(class Theorem extends AxiomLemmaTheoremConjecture {
   static name = "Theorem";
 
   static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
-
-  static fromTheoremNode(theoremNode, context) {
-    const node = theoremNode, ///
-          theorem = AxiomLemmaTheoremConjecture.fromNode(Theorem, node, context);
-
-    return theorem;
-  }
 });

package/src/element/type.js

@@ -2,18 +2,18 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
+
 import { define } from "../elements";
 import { BASE_TYPE_SYMBOL } from "../constants";
-import { typeFromTypeNode } from "../utilities/node.old";
 import { typeStringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/string";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
-class Type {
-  constructor(string, node, name, prefixName, superTypes, properties, provisional) {
-    this.string = string;
-    this.node = node;
+class Type extends Element {
+  constructor(context, string, node, name, prefixName, superTypes, properties, provisional) {
+    super(context, string, node);
     this.name = name;
     this.prefixName = prefixName;
     this.superTypes = superTypes;
@@ -21,14 +21,6 @@ class Type {
     this.provisional = provisional;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getName() {
     return this.name;
   }
@@ -310,78 +302,8 @@ class Type {
           typeName = name,  ///
           typePrefixName = null,
           string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-
-  static fromTypeNode(typeNode, context) {
-    const type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromSuperTypeNode(superTypeNode, context) {
-    context = null; ///
-
-    const typeNode = superTypeNode, ///
-          type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromTypeAndProvisional(type, provisional) {
-    const name = type.getName(),
-          prefixName = type.getPrefixName(),
-          superType = type, ///
-          typeName = name,  ///
-          typePrefixName = prefixName,  ///
-          superTypes = [
-            superType
-          ],
-          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          properties = type.getProperties();
-
-    type = new Type(string, node, name, prefixName, superTypes, properties, provisional);  ///
-
-    return type;
-  }
-
-  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
-    const typeNode = propertyDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, context);
-
-    return type;
-  }
-
-  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-    const typeName = simpleTypeDeclarationNode.getTypeName(),
-          provisional = simpleTypeDeclarationNode.isProvisional(),
-          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
-          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-          name = typeName,  ///
-          prefixName = typePrefixName,  ///
-          properties = [],
-          string = typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    let type;
-
-    const typeNode = constructorDeclarationNode.getTypeNode();
-
-    if (typeNode === null) {
-      type = baseType;
-    } else {
-      const provisional = constructorDeclarationNode.isProvisional();
-
-      type = typeFromTypeNode(typeNode, context);
-
-      type.setProvisional(provisional);
-    }
+          node = null,
+          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -389,34 +311,17 @@ class Type {
 
 export default define(Type);
 
-function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),
-        superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromSuperTypeNode(superTypeNode, context);
-
-          return superType;
-        }),
-        superTypesLength = superTypes.length;
-
-  if (superTypesLength === 0) {
-    const superType = baseType; ///
-
-    superTypes.push(superType);
-  }
-
-  return superTypes;
-}
-
 class BaseType extends Type {
   static fromNothing() {
     const name = BASE_TYPE_SYMBOL,  ///
+          context = null,
           string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          baseType = new BaseType(string, node, name, prefixName, superTypes, properties, provisional);
+          baseType = new BaseType(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return baseType;
   }