occam-verify-cli 1.0.457 → 1.0.472

package/src/element/variable.js

@@ -4,8 +4,8 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiateVariable } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { synthetically } from "../utilities/context";
+import { typeToTypeJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
   constructor(context, string, node, type, identifier, propertyRelations) {
@@ -34,18 +34,26 @@ export default define(class Variable extends Element {
 
   getTypeString() { return this.type.getString(); }
 
-  compareParameter(parameter) {
-    const parameterName = parameter.getName(),
-          identifierParamterName = (this.identifier === parameterName),
-          comparesToParamter = identifierParamterName;  ///
+  isIdentifierEqualTo(identifier) {
+    const identifierEqualTo = (this.identifier === identifier);
+
+    return identifierEqualTo;
+  }
+
+  compareParamter(parameter) {
+    const identifier = parameter.getIdentifier(),
+          identifierEqualTo = this.isIdentifierEqualTo(identifier),
+          comparesToParamter = identifierEqualTo; ///
 
     return comparesToParamter;
   }
 
   compareVariableIdentifier(variableIdentifier) {
-    const comparesToVariablbeIdentifier = (this.identifier === variableIdentifier);
+    const identifier = variableIdentifier, ///
+          identifierEqualTo = this.isIdentifierEqualTo(identifier),
+          comparesToVariableIdentifier = identifierEqualTo; ///
 
-    return comparesToVariablbeIdentifier;
+    return comparesToVariableIdentifier;
   }
 
   validate(context) {
@@ -103,27 +111,27 @@ export default define(class Variable extends Element {
   unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnifies = false;
 
-    const termString = term.getString(),
+    const context = specificContext,  ///
+          termString = term.getString(),
           variableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+    context.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    let context,
-        variable;
+    let variable;
 
     variable = this; ///
 
     const substitution = substitutions.findSubstitutionByVariable(variable);
 
     if (substitution !== null) {
-      context = specificContext;  ///
-
-      const substitutionTermEqualToTerm = substitution.isTermEqualToTerm(term, context);
+      const substitutionComparesToTerm = substitution.compareTerm(term, context);
 
-      if (substitutionTermEqualToTerm) {
+      if (substitutionComparesToTerm) {
         termUnifies = true;
       }
     } else {
+      let context;
+
       context = generalContext;  ///
 
       const variableIdentifier = variable.getIdentifier();
@@ -141,18 +149,18 @@ export default define(class Variable extends Element {
             termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = elements,
-              termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
-              substitution = termSubstitution;  ///
+        synthetically((context) => {
+          const { TermSubstitution } = elements;
 
-        substitutions.addSubstitution(substitution, context);
+          TermSubstitution.fromTermAndVariable(term, variable, context);
+        }, generalContext, specificContext);
 
         termUnifies = true;
       }
     }
 
     if (termUnifies) {
-      specificContext.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
+      context.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
     }
 
     return termUnifies;
@@ -173,15 +181,6 @@ export default define(class Variable extends Element {
   static name = "Variable";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          variableNode = instantiateVariable(string, context),
-          variableIdentifier = variableNode.getVariableIdentifier(),
-          node = variableNode,
-          identifier = variableIdentifier,  ///
-          type = typeFromJSON(json, context),
-          propertyRelations = [],
-          variable = new Variable(context, string, node, type, identifier, propertyRelations);
-
-    return variable;
+    ///
   }
 });

package/src/index.js

@@ -2,7 +2,8 @@
 
 import "./preamble";
 
-export { default as Log } from "./log";
+export { Log } from "occam-furtle";
+
 export { default as FileContext } from "./context/file";
 export { default as ReleaseContext } from "./context/release";
 export { default as releaseUtilities } from "./utilities/release";

package/src/main.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import Log from "./log";
+import { Log } from "occam-furtle";
+
 import helpAction from "./action/help";
 import verifyAction from "./action/verify";
 import versionAction from "./action/version";

package/src/node/frame.js

@@ -22,7 +22,7 @@ export default class FrameNode extends NonTerminalNode {
 
     const metavariableNode = this.getMetavariableNode();
 
-    if (metavariableName !== null) {
+    if (metavariableNode !== null) {
       metavariableName = metavariableNode.getMetavariableName();
     }
 

package/src/node/metavariable.js

@@ -6,7 +6,7 @@ import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 
 export default class MetavariableNode extends NonTerminalNode {
   getMetavariableName() {
-    let metaVariableName;
+    let metavariableName;
 
     this.someChildNode((childNode) => {
       const childNodeTerminalNode = childNode.isTerminalNode();
@@ -15,13 +15,13 @@ export default class MetavariableNode extends NonTerminalNode {
         const terminalNode = childNode, ///
               content = terminalNode.getContent();
 
-        metaVariableName = content; ///
+        metavariableName = content; ///
 
         return true;
       }
     });
 
-    return metaVariableName;
+    return metavariableName;
   }
 
   getTermNode() {

package/src/node/parameter.js

@@ -2,22 +2,49 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { NAME_TOKEN_TYPE, IDENTIFIER_TOKEN_TYPE } from "../tokenTypes";
+
 export default class ParameterNode extends NonTerminalNode {
-  getParameterName() {
-    let parameterName;
+  getName() {
+    let name = null;
 
     this.someChildNode((childNode, index) => {
       const terminalNode = childNode, ///
-            content = terminalNode.getContent();
+            type = terminalNode.getType();
+
+      if (type === NAME_TOKEN_TYPE) {
+        const content = terminalNode.getContent();
+
+        name = content;  ///
+      }
+
+      if (index === 0) {
+        return true;
+      }
+    });
 
-      parameterName = content;  ///
+    return name;
+  }
+
+  getIdentifier() {
+    let identifier = null;
+
+    this.someChildNode((childNode, index) => {
+      const terminalNode = childNode, ///
+            type = terminalNode.getType();
+
+      if (type === IDENTIFIER_TOKEN_TYPE) {
+        const content = terminalNode.getContent();
+
+        identifier = content;  ///
+      }
 
       if (index === 0) {
         return true;
       }
     });
 
-    return parameterName;
+    return identifier;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }

package/src/node/substitution/frame.js

@@ -5,44 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { FRAME_RULE_NAME } from "../../ruleNames";
 
 export default class FrameSubstitutionNode extends SubstitutionNode {
-  getFrameNode() {
-    const firstFrameNode = this.getFirstFrameNode(),
-          frameNode = firstFrameNode; ///
-
-    return frameNode;
-  }
-
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastMetavariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getLastMetavariableNode() {
-    let lastMetavariableNode = null;
-
+  getTargetFrameNode() {
     const lastFrameNode = this.getLastFrameNode(),
-          singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      lastMetavariableNode = singularMetavariableNode;  ///
-    }
+          targetFrameNode = lastFrameNode; ///
 
-    return lastMetavariableNode;
+    return targetFrameNode;
   }
 
-  getFirstMetavariableNode() {
-    let firstMetavariableNode = null;
-
+  getReplacementFrameNode() {
     const firstFrameNode = this.getFirstFrameNode(),
-          singularMetavariableNode = firstFrameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      firstMetavariableNode = singularMetavariableNode;  ///
-    }
+          replacementFrameNode = firstFrameNode; ///
 
-    return firstMetavariableNode;
+    return replacementFrameNode;
   }
 
   getLastFrameNode() {

package/src/node/substitution/reference.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import SubstitutionNode from "../../node/substitution";
+
+import { REFERENCE_RULE_NAME } from "../../ruleNames";
+
+export default class ReferenceSubstitutionNode extends SubstitutionNode {
+  getTargetReferenceNode() {
+    const lastReferenceNode = this.getLastReferenceNode(),
+          targetReferenceNode = lastReferenceNode; ///
+
+    return targetReferenceNode;
+  }
+
+  getReplacementReferenceNode() {
+    const firstReferenceNode = this.getFirstReferenceNode(),
+          replacementReferenceNode = firstReferenceNode; ///
+
+    return replacementReferenceNode;
+  }
+
+  getLastReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          lastReferenceNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastReferenceNode;
+  }
+
+  getFirstReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          firstReferenceNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstReferenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}
+

package/src/node/substitution/statement.js

@@ -5,44 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class StatementSubstitutionNode extends SubstitutionNode {
-  getStatementNode() {
-    const firstStatementNode = this.getFirstStatementNode(),
-          statementNode = firstStatementNode; ///
-
-    return statementNode;
-  }
-
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastMetavariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getLastMetavariableNode() {
-    let lastMetavariableNode = null;
-
+  getTargetStatementNode() {
     const lastStatementNode = this.getLastStatementNode(),
-          singularMetavariableNode = lastStatementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      lastMetavariableNode = singularMetavariableNode;  ///
-    }
+          targetStatementNode = lastStatementNode; ///
 
-    return lastMetavariableNode;
+    return targetStatementNode;
   }
 
-  getFirstMetavariableNode() {
-    let firstMetavariableNode = null;
-
+  getReplacementStatementNode() {
     const firstStatementNode = this.getFirstStatementNode(),
-          singularMetavariableNode = firstStatementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      firstMetavariableNode = singularMetavariableNode;  ///
-    }
+          replacementStatementNode = firstStatementNode; ///
 
-    return firstMetavariableNode;
+    return replacementStatementNode;
   }
 
   getLastStatementNode() {

package/src/node/substitution/term.js

@@ -5,34 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
 export default class TermSubstitutionNode extends SubstitutionNode {
-  getTermNode() {
-    const firstTermNode = this.getFirstTermNode(),
-          termNode = firstTermNode; ///
-
-    return termNode;
-  }
-
-  getVariableNode() {
-    const lastVariableNode = this.getLastVariableNode(),
-          variableNode = lastVariableNode;  ///
-
-    return variableNode;
-  }
-
-  getLastVariableNode() {
+  getTargetTermNode() {
     const lastTermNode = this.getLastTermNode(),
-          singularVariableNode = lastTermNode.getSingularVariableNode(),
-          lastVariableNode = singularVariableNode;  ///
+          targetTermNode = lastTermNode; ///
 
-    return lastVariableNode;
+    return targetTermNode;
   }
 
-  getFirstVariableNode() {
+  getReplacementTermNode() {
     const firstTermNode = this.getFirstTermNode(),
-          singularVariableNode = firstTermNode.getSingularVariableNode(),
-          firstVariableNode = singularVariableNode;  ///
+          replacementTermNode = firstTermNode; ///
 
-    return firstVariableNode;
+    return replacementTermNode;
   }
 
   getLastTermNode() {

package/src/nonTerminalNodeMap.js

@@ -75,6 +75,7 @@ import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
+import ReferenceSubstitutionNode from "./node/substitution/reference";
 import StatementSubstitutionNode from "./node/substitution/statement";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
@@ -159,6 +160,7 @@ import {
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
   VARIABLE_DECLARATION_RULE_NAME,
+  REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
   COMBINATOR_DECLARATION_RULE_NAME,
   SIMPLE_TYPE_DECLARATION_RULE_NAME,
@@ -244,6 +246,7 @@ const NonTerminalNodeMap = {
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
+  [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
   [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,

package/src/process/instantiate.js

@@ -2,26 +2,22 @@
 
 import { ruleFromRuleName } from "../utilities/bnf";
 import { TERM_RULE_NAME,
-         VARIABLE_RULE_NAME,
          REFERENCE_RULE_NAME,
          STATEMENT_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
-         METAVARIABLE_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
-      variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
-      metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
@@ -29,8 +25,6 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
 
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
 
-export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
-
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
@@ -41,8 +35,6 @@ export function instantiateConstructor(string, context) { return instantiate(con
 
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
-export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
-
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }

package/src/process/unify.js

@@ -486,7 +486,7 @@ class IntrinsicLevelPass extends Pass {
     {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
         let success = false;
 
         const termNode = specificTermNode, ///
@@ -502,7 +502,7 @@ class IntrinsicLevelPass extends Pass {
         context = specificContext;  ///
 
         const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
 
         if (termUnifies) {
           success = true;
@@ -612,14 +612,14 @@ export function unifyStatementWithCombinator(statement, combinator, assignments,
   return statementUnifiesWithCombinator;
 }
 
-export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
+export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
   const generalMetavariableNode = generalMetavariable.getNode(),
         specificMetavariableNode = specificMetavariable.getNode(),
         generalNode = generalMetavariableNode, ///
         specificNode = specificMetavariableNode, ///
-        success = intrinsicLevelPass.run(generalNode, specificNode, substitutions, generalContext, specificContext);
+        success = intrinsicLevelPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     metavariableUnifiesIntrinsically = true;

package/src/tokenTypes.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export const NAME_TOKEN_TYPE = "name";
+export const IDENTIFIER_TOKEN_TYPE = "identifier";

package/src/utilities/context.js

@@ -1,20 +1,46 @@
 "use strict";
 
-import { FUNCTION } from "../constants";
-
-export function chainContext(context) {
-  return new Proxy(context, {
-    get: (instance, name, receiver) => {
-      if (name in instance) {
-        return Reflect.get(instance, name, receiver);
-      }
-
-      const context = instance.context,
-            value = context[name];
-
-      return (typeof value === FUNCTION) ?
-               value.bind(context) :
-                 value;
-    }
-  });
+import ScopedContext from "../context/scoped";
+import LiminalContext from "../context/liminal";
+import LiteralContext from "../context/literal";
+import EphemeralContext from "../context/ephemeral";
+import SyntheticContext from "../context/synthetic";
+
+export function scope(innerFunction, context) {
+  const scopedContext = ScopedContext.fromNothing(context);
+
+  context = scopedContext;  ///
+
+  return innerFunction(context);
+}
+
+export function attempt(innerFunction, context) {
+  const ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext;  ///
+
+  return innerFunction(context);
+}
+
+export function liminally(innerFunction, context) {
+  const liminalContext = LiminalContext.fromNothing(context);
+
+  context = liminalContext;  ///
+
+  return innerFunction(context);
+}
+
+export function literally(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
+
+  return innerFunction(context);
+}
+
+export function synthetically(innerFunction, generalContext, specificContext) {
+  const syntheticContext = SyntheticContext.fromNothing(generalContext, specificContext),
+        context = syntheticContext;  ///
+
+  return innerFunction(context);
 }