occam-verify-cli 0.0.526 → 0.0.527

package/src/matcher/termForVariable.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import Matcher from "../matcher";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+
+import { nodeQuery } from "../utilities/query";
+import { TERM_RULE_NAME } from "../ruleNames";
+import { variableNameFromVariableNode } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery('/term/variable!');
+
+export default class TermForVariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      const nonTerminalNodeARuleNameTermRuleName = (nonTerminalNodeARuleName === TERM_RULE_NAME),
+            nonTerminalNodeBRuleNameTermRuleName = (nonTerminalNodeBRuleName === TERM_RULE_NAME);
+
+      if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
+        const termNodeA = nonTerminalNodeA,  ///
+              termNodeB = nonTerminalNodeB,  ///
+              termNodeMatches = this.matchTermNode(termNodeA, termNodeB, substitutions);
+
+        if (termNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        }
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchTermNode(termNodeA, termNodeB, substitutions) {
+    let termNodeMatches = false;
+
+    const variableNodeA = variableNodeQuery(termNodeA);
+
+    if (variableNodeA !== null) {
+      const variableMatches = this.matchVariableNode(variableNodeA, termNodeB, substitutions);
+
+      termNodeMatches = variableMatches; ///
+    }
+
+    return termNodeMatches;
+  }
+
+  matchVariableNode(variableNodeB, termNodeB, substitutions) {
+    let variableMatches;
+
+    const variableNameA = variableNameFromVariableNode(variableNodeB),
+          substitution = substitutions.find((substitution) => {
+            const variableName = substitution.getVariableName();
+
+            if (variableName === variableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const termNode = termNodeB, ///
+            substitutionNodesMatch = substitution.matchTermNode(termNode);
+
+      variableMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const variableName = variableNameA, ///
+              termNode = termNodeB, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      variableMatches = true;
+    }
+
+    return variableMatches;
+  }
+}

package/src/matcher.js

@@ -1,41 +1,47 @@
 "use strict";
 
 export default class Matcher {
-  matchNode(nodeA, nodeB, ...remainingArguments) {
+  matchNode(nodeA, nodeB, substitutions, depth = Infinity) {
     let nodeMatches = false;
 
-    const nodeATerminalNode = nodeA.isTerminalNode(),
-          nodeBTerminalNode = nodeB.isTerminalNode();
-
-    if (nodeATerminalNode === nodeBTerminalNode) {
-      if (nodeATerminalNode) {
-        const terminalNodeA = nodeA,  ///
-              terminalNodeB = nodeB,  ///
-              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
-
-        nodeMatches = terminalNodeMatches;  ///
-      } else {
-        const nonTerminalNodeA = nodeA,  ///
-              nonTerminalNodeB = nodeB, ///
-              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
-
-        nodeMatches = nonTerminalNodeMatches; ///
+    if (depth === 0) {
+      nodeMatches = true;
+    } else {
+      const nodeATerminalNode = nodeA.isTerminalNode(),
+            nodeBTerminalNode = nodeB.isTerminalNode();
+
+      if (nodeATerminalNode === nodeBTerminalNode) {
+        if (nodeATerminalNode) {
+          const terminalNodeA = nodeA,  ///
+                terminalNodeB = nodeB,  ///
+                terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB);
+
+          nodeMatches = terminalNodeMatches;  ///
+        } else {
+          const nonTerminalNodeA = nodeA,  ///
+                nonTerminalNodeB = nodeB, ///
+                nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, depth);
+
+          nodeMatches = nonTerminalNodeMatches; ///
+        }
       }
     }
 
     return nodeMatches;
   }
 
-  matchNodes(nodesA, nodesB, ...remainingArguments) {
+  matchNodes(nodesA, nodesB, substitutions, depth = Infinity) {
     let nodesMatch = false;
 
     const nodesALength = nodesA.length,
           nodesBLength = nodesB.length;
 
     if (nodesALength === nodesBLength) {
+      depth --;
+
       nodesMatch = nodesA.every((nodeA, index) => {
         const nodeB = nodesB[index],
-              nodeMatches = this.matchNode(nodeA, nodeB, ...remainingArguments);
+              nodeMatches = this.matchNode(nodeA, nodeB, substitutions, depth);
 
         if (nodeMatches) {
           return true;
@@ -46,14 +52,14 @@ export default class Matcher {
     return nodesMatch;
   }
 
-  matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+  matchTerminalNode(terminalNodeA, terminalNodeB, substitutions, depth) {
     const matches = terminalNodeA.match(terminalNodeB),
           terminalNodeMatches = matches;  ///
 
     return terminalNodeMatches;
   }
 
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, depth = Infinity) {
     let nonTerminalNodeMatches = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
@@ -64,7 +70,7 @@ export default class Matcher {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             nodesA = nonTerminalNodeAChildNodes, ///
             nodesB = nonTerminalNodeBChildNodes, ///
-            nodesMatch = this.matchNodes(nodesA, nodesB, ...remainingArguments);
+            nodesMatch = this.matchNodes(nodesA, nodesB, substitutions, depth);
 
       nonTerminalNodeMatches = nodesMatch; ///
     }

package/src/mixins/file.js

@@ -1,12 +1,57 @@
 "use strict";
 
+function getAxioms() { return this.context.getAxioms(); }
+
+function getLemmas() { return this.context.getLemmas(); }
+
+function getTheorems() { return this.context.getTheorems(); }
+
+function getConjectures() { return this.context.getConjectures(); }
+
+function getCombinators() { return this.context.getCombinators(); }
+
+function getConstructors() { return this.context.getConstructors(); }
+
+function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+function findLabelByTypeName(labelName) { return this.context.findLabelByTypeName(labelName); }
+
 function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
 
 function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
 
+function findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
+
+function findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
+
+function findConjectureByReferenceName(referenceName) { return this.context.findConjectureByReferenceName(referenceName); }
+
+function isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
+
+function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+function nodeAsString(node) { return this.context.nodeAsString(node); }
+
+function nodesAsString(node) { return this.context.nodesAsString(node); }
+
 const fileMixins = {
+  getAxioms,
+  getLemmas,
+  getTheorems,
+  getConjectures,
+  getCombinators,
+  getConstructors,
+  findTypeByTypeName,
+  findLabelByTypeName,
   findRuleByReferenceName,
-  findAxiomByReferenceName
+  findAxiomByReferenceName,
+  findLemmaByReferenceName,
+  findTheoremByReferenceName,
+  findConjectureByReferenceName,
+  isLabelPresentByLabelName,
+  isTypePresentByTypeName,
+  nodeAsString,
+  nodesAsString
 };
 
 export default fileMixins;

package/src/premise.js

@@ -34,12 +34,12 @@ export default class Premise {
               ...subproofSuppositionStatementNodes,
               subproofSubDerivationLastStatementNode
             ],
-            ruleSubproofAssertionMetaSubproofStatementNodes = ruleSubproofAssertionMetaSubproofStatementNodesQuery(subproofAssertionNode),
+            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(subproofAssertionNode),
             subproofStatementNodesLength = subproofStatementNodes.length,
-            ruleSubproofAssertionMetaSubproofStatementNodesLength = ruleSubproofAssertionMetaSubproofStatementNodes.length;
+            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
 
-      if (subproofStatementNodesLength === ruleSubproofAssertionMetaSubproofStatementNodesLength) {
-        subproofNodeMatches = ruleSubproofAssertionMetaSubproofStatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
+      if (subproofStatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
+        subproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///

package/src/ruleNames.js

@@ -5,9 +5,7 @@ export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
-export const VARIABLE_RULE_NAME = "variable";
 export const STATEMENT_RULE_NAME = "statement";
-export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";

package/src/step/proof.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { matchBracketedNonTerminalNode } from "../utilities/substitution";
+
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
     this.subproofNode = subproofNode;
@@ -14,6 +16,31 @@ export default class ProofStep {
     return this.statementNode;
   }
 
+  matchStatement(statementNode) {
+    let statementMatches;
+
+    const statementsMatch = this.matchStatements(statementNode);
+
+    statementMatches = statementsMatch; //
+
+    return statementMatches;
+  }
+
+  matchStatements(statementNode) {
+    let statementsMatch = false;
+
+    if (this.statementNode !== null) {
+      const nonTerminalNodeA = statementNode, ///
+            nonTerminalNodeB = this.statementNode,  ///
+            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
+            statementNodeMatches = bracketedNodeMatches;  ///
+
+      return statementNodeMatches;
+    }
+
+    return statementsMatch;
+  }
+
   static fromSubproofNode(subproofNode) {
     const statementNode = null,
           metaProofStep = new ProofStep(subproofNode, statementNode);

package/src/substitution/statementForMetavariable.js

@@ -1,9 +1,12 @@
 "use strict";
 
 import { matcher } from "../matcher";
-import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { nodeQuery } from "../utilities/query";
+import { META_ARGUMENT_RULE_NAME } from "../ruleNames";
 import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
 
+const statementNodeQuery = nodeQuery('/metaArgument/statement!');
+
 export default class StatementForMetavariableSubstitution {
   constructor(metavariableName, statementNode) {
     this.metavariableName = metavariableName;
@@ -30,16 +33,19 @@ export default class StatementForMetavariableSubstitution {
     if (!matchesStatementNode) {
       const nonTerminalNode = statementNode,  ///
             childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = STATEMENT_RULE_NAME;
+            ruleName = META_ARGUMENT_RULE_NAME,
+            metaArgumentNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+      if (metaArgumentNode !== null) {
+        const statementNode = statementNodeQuery(metaArgumentNode);
 
-      if (statementNode !== null) {
-        const nodeA = this.statementNode,  ///
-              nodeB = statementNode,
-              nodeMatches = matchNode(nodeA, nodeB);
+        if (statementNode !== null) {
+          const nodeA = this.statementNode,  ///
+                nodeB = statementNode,
+                nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-        matchesStatementNode = nodeMatches;  ///
+          matchesStatementNode = nodeMatches;  ///
+        }
       }
     }
 
@@ -51,9 +57,10 @@ export default class StatementForMetavariableSubstitution {
 
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = STATEMENT_RULE_NAME;
+          ruleName = META_ARGUMENT_RULE_NAME,
+          metaArgumentNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+    statementNode = statementNodeQuery(metaArgumentNode);
 
     if (statementNode !== null) {
       statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);

package/src/substitution/termForVariable.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import { matcher } from "../matcher";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+
+export default class TermForVariableSubstitution {
+  constructor(variableName, termNode) {
+    this.variableName = variableName;
+    this.termNode = termNode;
+  }
+
+  getVariableName() {
+    return this.variableName;
+  }
+
+  getTermNode() {
+    return this.termNode;
+  }
+
+  matchTermNode(termNode) {
+    let matchesTermNode;
+
+    const nodeA = this.termNode,  ///
+          nodeB = termNode,
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    matchesTermNode = nodeMatches;  ///
+
+    if (!matchesTermNode) {
+      const nonTerminalNode = termNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = STATEMENT_RULE_NAME;
+
+      termNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+      if (termNode !== null) {
+        const nodeA = this.termNode,  ///
+              nodeB = termNode,
+              nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+        matchesTermNode = nodeMatches;  ///
+      }
+    }
+
+    return matchesTermNode;
+  }
+
+  static fromVariableNameAndTermNode(variableName, termNode) {
+    let termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
+
+    const nonTerminalNode = termNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = STATEMENT_RULE_NAME;
+
+    termNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+    if (termNode !== null) {
+      termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
+    }
+
+    return termForVariableSubstitution;
+  }
+}

package/src/supposition.js

@@ -3,7 +3,7 @@
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/string";
-import { suppositionStatementForVariableMatcher } from "./matcher/statementForVariable/supposition";
+import { suppositionTermForVariableMatcher } from "./matcher/termForVariable/supposition";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
@@ -40,7 +40,7 @@ export default class Supposition {
                                 const subproofStatementNode = subproofStatementNodes[index],
                                       nonTerminalNodeA = subproofAssertionStatementNode,  ///
                                       nonTerminalNodeB = subproofStatementNode, ///
-                                      nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                                      nonTerminalNodeMatches = suppositionTermForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                 if (nonTerminalNodeMatches) {
                                   return true;
@@ -55,7 +55,7 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = suppositionTermForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;

package/src/theorem.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import AxiomLemmaTheorem from "./axiomLemmaTheorem";
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
 import { THEOREM_KIND } from "./kinds";
 
-export default class Theorem extends AxiomLemmaTheorem {
+export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
+  static fromJSON(json, releaseContext) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, releaseContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }

package/src/type.js

@@ -182,11 +182,21 @@ class ObjectType extends Type {
 export const objectType = ObjectType.fromNothing();
 
 function superTypeFromSuperTypeJSON(superTypeJSON, releaseContext) {
+  let superType;
+
   const json = superTypeJSON, ///
-        { name } = json,
-        superType = (name === OBJECT_TYPE_NAME) ?
-          objectType :
-            Type.fromJSON(json, releaseContext);
+        { name } = json;
+
+  if (name === OBJECT_TYPE_NAME) {
+    superType = objectType; ///
+  } else {
+    const typeName = name,  ///
+          type = releaseContext.findTypeByTypeName(typeName);
+
+    superType = (type !== null) ?
+                  type :  ///
+                    Type.fromJSON(json, releaseContext);  ///
+  }
 
   return superType;
 }

package/src/utilities/string.js

@@ -51,14 +51,12 @@ export function nodesAsString(nodes, tokens) {
   const string = nodes.reduce((string, node) => {
     const nodeString = nodeAsString(node, tokens);
 
-    if (string === null) {
-      string = nodeString;  ///
-    } else {
-      string = `${string}${COMMA}${nodeString}`;
-    }
+    string = (string === EMPTY_STRING) ?
+               nodeString :
+                `${string}${COMMA}${nodeString}`;
 
     return string;
-  }, null);
+  }, EMPTY_STRING);
 
   return string;
 }

package/src/utilities/substitution.js

@@ -1,4 +1,4 @@
-"use strict";
+    "use strict";
 
 import { matcher } from "../matcher";
 import { first, second, third } from "../utilities/array";
@@ -17,7 +17,8 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
           childNodesA = nonTerminalNodeAChildNodes, ///
-          bracketedNonTerminalChildNodeA = bracketedNonTerminalChildNodeFromChildNodes(childNodesA);
+          ruleName = METASTATEMENT_RULE_NAME,
+          bracketedNonTerminalChildNodeA = bracketedNonTerminalChildNodeFromChildNodes(childNodesA, ruleName);
 
     if (bracketedNonTerminalChildNodeA !== null) {
       const nodeA = bracketedNonTerminalChildNodeA,  ///
@@ -31,7 +32,8 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
           childNodesB = nonTerminalNodeBChildNodes, ///
-          bracketedNonTerminalChildNodeB = bracketedNonTerminalChildNodeFromChildNodes(childNodesB);
+          ruleName = METASTATEMENT_RULE_NAME,
+          bracketedNonTerminalChildNodeB = bracketedNonTerminalChildNodeFromChildNodes(childNodesB, ruleName);
 
     if (bracketedNonTerminalChildNodeB !== null) {
       const nodeB = bracketedNonTerminalChildNodeB,  ///
@@ -45,7 +47,7 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   return bracketedNodeMatches;
 }
 
-export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName = METASTATEMENT_RULE_NAME) {
+export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName) {
   let bracketedNonTerminalChildNode = null;
 
   const childNodesLength = childNodes.length;

package/src/variable.js

@@ -1,10 +1,9 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name, termNode) {
+  constructor(type, name) {
     this.type = type;
     this.name = name;
-    this.termNode = termNode;
   }
 
   getType() {
@@ -15,53 +14,21 @@ export default class Variable {
     return this.name;
   }
 
-  getTermNode() {
-    return this.termNode;
-  }
-
-  setTermNode(termNode) {
-    this.termNode = termNode;
-  }
-
   matchName(name) {
     const matchesName = (this.name === name);
 
     return matchesName;
   }
 
-  isEqualTo(variable) {
-    let equalTo = false;
-
-    if (variable === this) {
-      equalTo = true;
-    } else {
-      const termNode = variable.getTermNode();
-
-      if (termNode === this.termNode) {
-        equalTo = true;
-      }
-    }
-
-    return equalTo;
-  }
-
   asString(tokens) {
-    let string;
-
-    if (this.type === null) {
-      string = this.name;
-    } else {
-      const typeName = this.type.getName();
-
-      string = `${this.name}:${typeName}`;
-    }
+    const typeName = this.type.getName(),
+          string = `${this.name}:${typeName}`;
 
     return string;
   }
 
   static fromTypeAndName(type, name) {
-    const termNode = null,
-          variable = new Variable(type, name, termNode);
+    const variable = new Variable(type, name);
 
     return variable;
   }