occam-furtle 3.0.305 → 3.0.310

package/src/element/value.js

@@ -2,9 +2,9 @@
 
 import { Element } from "occam-languages";
 
+import elements from "../elements";
+
 import { define } from "../elements";
-import { BOOLEAN_TYPE } from "../types";
-import { valueFromBoolean } from "../utilities/value";
 
 export default define(class Value extends Element {
   constructor(context, string, node, breakPoint, variable, primitive) {
@@ -44,7 +44,8 @@ export default define(class Value extends Element {
 
   isBoolean() {
     const type = this.getType(),
-          boolean = (type === BOOLEAN_TYPE);
+          booleanType = type.isBooleanType(),
+          boolean = booleanType; ///
 
     return boolean;
   }
@@ -85,6 +86,29 @@ export default define(class Value extends Element {
     return equalTo;
   }
 
+  lift(context) {
+    const { Primitive } = elements,
+          primitiveValue = this.getPrimitiveValue(),
+          primitiveValues = primitiveValue; ///
+
+    let type;
+
+    type = this.getType();
+
+    const argumentType = type.getArgumentType();
+
+    type = argumentType;  ///
+
+    const values = primitiveValues.map((primitiveValue)=> {
+            const primitive = Primitive.fromPrimitiveValueAndType(primitiveValue, type, context),
+                  value = Value.fromPrimitive(primitive, context);
+
+            return value;
+          });
+
+    return values;
+  }
+
   static name = "Value";
 
   static fromPrimitive(primitive, context) {

package/src/element/variable.js

@@ -76,10 +76,12 @@ export default define(class Variable extends Element {
     }
 
     const valueType = value.getType(),
-          variableType = this.type;
+          typeEqualToValueType = this.type.isEqualTo(valueType);
 
-    if (valueType !== variableType) {
-      const message = `The '${variableString} variable's '${variableType}' type does not compare to the value's '${valueType}' type.'`,
+    if (!typeEqualToValueType) {
+      const typeString = this.type.getString(),
+            valueTypeString = valueType.getString(),
+            message = `The '${variableString} variable's '${typeString}' type does not compare to the value's '${valueTypeString}' type.'`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/node/assignments/variable.js

@@ -2,22 +2,14 @@
 
 import AssignmentsNode from "../../node/assignment";
 
-import { TYPE_TOKEN_TYPE } from "../../tokenTypes";
-import { VARIABLE_ASSIGNMENT_RULE_NAME } from "../../ruleNames";
+import { TYPE_RULE_NAME, VARIABLE_ASSIGNMENT_RULE_NAME } from "../../ruleNames";
 
 export default class VariableAssignmentsNode extends AssignmentsNode {
-  getType() {
-    let type;
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-    const tokenType = TYPE_TOKEN_TYPE;
-
-    this.someTerminalNode((terminalNode) => {
-      const content = terminalNode.getContent();
-
-      type = content;  ///
-    }, tokenType);
-
-    return type;
+    return typeNode;
   }
 
   getVariableAssignmentNodes() {

package/src/node/binding/named.js

@@ -11,7 +11,7 @@ export default class NamedBindingNode extends BindingNode {
     const tokenType = NAME_TOKEN_TYPE;
 
     this.someTerminalNode((terminalNode, index) => {
-      if (index === 3) {
+      if (index === 1) {
         const content = terminalNode.getContent();
 
         alias = content; //

package/src/node/binding.js

@@ -1,61 +1,50 @@
 "use strict";
 
-import { types } from "occam-lexers";
 import { NonTerminalNode } from "occam-languages";
 
-import { TYPE_TOKEN_TYPE, NAME_TOKEN_TYPE } from "../tokenTypes";
-
-const { epsilon } = types;
+import { TYPE_RULE_NAME } from "../ruleNames";
+import { NAME_TOKEN_TYPE } from "../tokenTypes";
 
 export default class BindingNode extends NonTerminalNode {
-  getName() {
-    let name = null;
+  isElided() {
+    let elided = false;
 
-    const tokenType = NAME_TOKEN_TYPE;
+    const tokenType = null
 
     this.someTerminalNode((terminalNode) => {
-      const content = terminalNode.getContent();
+      const terminalNodeEpsilonNode = terminalNode.isEpsilonNode();
 
-      name = content; //
+      if (terminalNodeEpsilonNode) {
+        elided = true;
+      }
 
       return true;
     }, tokenType);
 
-    return name;
+    return elided;
   }
 
-  getType() {
-    let type = null;
+  getName() {
+    let name = null;
 
-    const tokenType = TYPE_TOKEN_TYPE;
+    const tokenType = NAME_TOKEN_TYPE;
 
     this.someTerminalNode((terminalNode) => {
       const content = terminalNode.getContent();
 
-      type = content; //
+      name = content; //
 
       return true;
     }, tokenType);
 
-    return type;
+    return name;
   }
 
-  isElided() {
-    let elided = false;
-
-    const tokenType = null
-
-    this.someTerminalNode((terminalNode) => {
-      const terminalNodeEpsilonNode = terminalNode.isEpsilonNode();
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-      if (terminalNodeEpsilonNode) {
-        elided = true;
-      }
-
-      return true;
-    }, tokenType);
-
-    return elided;
+    return typeNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) {

package/src/node/declaration/procedure.js

@@ -2,22 +2,14 @@
 
 import DeclarationNode from "../../node/declaration";
 
-import { TYPE_TOKEN_TYPE } from "../../tokenTypes";
-import { LABEL_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../../ruleNames";
+import { TYPE_RULE_NAME, LABEL_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../../ruleNames";
 
 export default class ProcedureDeclarationNode extends DeclarationNode {
-  getType() {
-    let type;
-
-    const tokenType = TYPE_TOKEN_TYPE;
-
-    this.someTerminalNode((terminalNode) => {
-      const content = terminalNode.getContent();
-
-      type = content;  ///
-    }, tokenType);
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          labelNode = this.getNodeByRuleName(ruleName);
 
-    return type;
+    return labelNode;
   }
 
   getLabelNode() {

package/src/node/parameter.js

@@ -2,7 +2,8 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { TYPE_TOKEN_TYPE, NAME_TOKEN_TYPE } from "../tokenTypes";
+import { TYPE_RULE_NAME } from "../ruleNames";
+import { NAME_TOKEN_TYPE } from "../tokenTypes";
 
 export default class ParameterNode extends NonTerminalNode {
   getName() {
@@ -21,20 +22,11 @@ export default class ParameterNode extends NonTerminalNode {
     return name;
   }
 
-  getType() {
-    let type = null;
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-    const tokenType = TYPE_TOKEN_TYPE;
-
-    this.someTerminalNode((terminalNode) => {
-      const content = terminalNode.getContent();
-
-      type = content; //
-
-      return true;
-    }, tokenType);
-
-    return type;
+    return typeNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }

package/src/node/primitive.js

@@ -5,12 +5,12 @@ import { NonTerminalNode } from "occam-languages";
 import NominalValue from "../nominalValue";
 
 import { NULL, TRUE, FALSE } from "../constants";
-import { STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE, NOMINAL_VALUE_TYPE } from "../types";
+import { STRING_TYPE_NAME, NUMBER_TYPE_NAME, BOOLEAN_TYPE_NAME, NOMINAL_VALUE_TYPE_NAME } from "../typeNames";
 import { NULL_TOKEN_TYPE, NUMBER_TOKEN_TYPE, BOOLEAN_TOKEN_TYPE, STRING_LITERAL_TOKEN_TYPE } from "../tokenTypes";
 
 export default class PrimitiveNode extends NonTerminalNode {
-  getType() {
-    let type;
+  getTypeName() {
+    let typeName;
 
     const number = this.getNumber(),
           boolean = this.getBoolean(),
@@ -20,16 +20,16 @@ export default class PrimitiveNode extends NonTerminalNode {
     if (false) {
       ///
     } else if (number !== null) {
-      type = NUMBER_TYPE;
+      typeName = NUMBER_TYPE_NAME;
     } else if (boolean !== null) {
-      type = BOOLEAN_TYPE;
+      typeName = BOOLEAN_TYPE_NAME;
     } else if (nominalvalue !== null) {
-      type = NOMINAL_VALUE_TYPE;
+      typeName = NOMINAL_VALUE_TYPE_NAME;
     } else if (stringLiteral !== null) {
-      type = STRING_TYPE;
+      typeName = STRING_TYPE_NAME;
     }
 
-    return type;
+    return typeName;
   }
 
   getValue() {

package/src/node/procedure/anoymous.js

@@ -2,22 +2,14 @@
 
 import ProcedureNode from "../../node/procedure";
 
-import { TYPE_TOKEN_TYPE } from "../../tokenTypes";
-import { PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../../ruleNames";
+import { TYPE_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../../ruleNames";
 
 export default class AnonymousProcedureNode extends ProcedureNode {
-  getType() {
-    let type;
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-    const tokenType = TYPE_TOKEN_TYPE;
-
-    this.someTerminalNode((terminalNode) => {
-      const content = terminalNode.getContent();
-
-      type = content;  ///
-    }, tokenType);
-
-    return type;
+    return typeNode;
   }
 
   getParametersNode() {

package/src/node/type.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { TYPE_TOKEN_TYPE } from "../tokenTypes";
+
+export default class TypeNode extends NonTerminalNode {
+  getName() {
+    let name = null;
+
+    const tokenType = TYPE_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      name = content; //
+
+      return true;
+    }, tokenType);
+
+    return name;
+  }
+
+  getArgumentTypeName() {
+    let argumentTypeName = null;
+
+    const tokenType = TYPE_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode, index) => {
+      if (index === 1) {
+        const content = terminalNode.getContent();
+
+        argumentTypeName = content; //
+
+        return true;
+      }
+    }, tokenType);
+
+    return argumentTypeName;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nominalValueProperties.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import elements from "./elements";
+import Exception from "./exception";
+import NominalValueProperty from "./nominalValueProperty";
+
+import { nominalValuePropertiesStringFromNominalValuePropertiesArray } from "./utilities/string";
+import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "./parameterNames";
+import { LIST_TYPE_NAME, STRING_TYPE_NAME, BOOLEAN_TYPE_NAME, NOMINAL_VALUE_TYPE_NAME } from "./typeNames";
+
+class NominalValueProperties {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  someNominalValueProperty(callback) { return this.array.some(callback); }
+
+  compareNamedBinding(namedBinding, context) {
+    const namedBindingString = namedBinding.getString(),
+          nominalValuePropertiesString = this.string; ///
+
+    context.trace(`Comparing the '${namedBindingString}' named binding with the '${nominalValuePropertiesString}' node properties...`);
+
+    const namedBindingsCompare = this.someNominalValueProperty((nominalValueProperty) => {
+      const namedBindingComparesToNominalValueProperty = nominalValueProperty.compareNamedBinding(namedBinding, context);
+
+      if (namedBindingComparesToNominalValueProperty) {
+        return true;
+      }
+    });
+
+    if (!namedBindingsCompare) {
+      const message = `The '${namedBindingString}' named binding does not compmare to any of the '${nominalValuePropertiesString}' node properties.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...compared the '${namedBindingString}' named binding with the '${nominalValuePropertiesString}' node properties.`);
+  }
+
+  compareNamedBindings(namedBindings, context) {
+    namedBindings.forEachNamedBinding((namedBinding) => {
+      this.compareNamedBinding(namedBinding, context);
+    });
+  }
+
+  static fromNothing() {
+    const nominalValuePropertiesArray = nominalValuePropertiesArrayFromNothing(),
+          string = nominalValuePropertiesStringFromNominalValuePropertiesArray(nominalValuePropertiesArray),
+          array = nominalValuePropertiesArray,  ///
+          nominalValueProperties = new NominalValueProperties(string, array);
+
+    return nominalValueProperties;
+  }
+}
+
+const nominalValueProperties = NominalValueProperties.fromNothing();
+
+export default nominalValueProperties;
+
+function nominalValuePropertiesArrayFromNothing() {
+  const names = [
+          CONTENT_PARAMETER_NAME,
+          TERMINAL_PARAMETER_NAME,
+          CHILD_NODES_PARAMETER_NAME
+        ],
+        typeNames = [
+          STRING_TYPE_NAME,
+          BOOLEAN_TYPE_NAME,
+          LIST_TYPE_NAME
+        ],
+        argumentTypeNames = [
+          null,
+          null,
+          NOMINAL_VALUE_TYPE_NAME
+        ],
+        types = typeNames.map((typeName, index) => {
+          const { Type } = elements,
+                context = null,
+                argumentTypeName = argumentTypeNames[index],
+                type = Type.fromTypeNameAndArgumentTypeName(typeName, argumentTypeName, context);
+
+          return type;
+        }),
+        nominalValuePropertiesArray = names.map((name, index) => {
+          const type = types[index],
+                nominalValueProperty = NominalValueProperty.fromNameAndType(name, type);
+
+          return nominalValueProperty;
+        });
+
+  return nominalValuePropertiesArray;
+}

package/src/nominalValueProperty.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import { nominalValuePropertyStringFromNameAndType } from "./utilities/string";
+
+export default class NominalValueProperty {
+  constructor(string, type, name) {
+    this.string = string;
+    this.type = type;
+    this.name = name;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  compareNamedBinding(namedBinding, context) {
+    let namedBindingCompares;
+
+    const nominalValuePropertyString = this.string, ///
+          namedBindingString = namedBinding.getString();
+
+    context.trace(`Comparing the '${nominalValuePropertyString}' node property with the '${namedBindingString}' named binding...`);
+
+    const namedBindingName = namedBinding.getName(),
+          namedBindingType = namedBinding.getType(),
+          nameEqualToNamedBindingName = (this.name === namedBindingName),
+          typeEqualToNamedBindingType = this.type.isEqualTo(namedBindingType);
+
+    namedBindingCompares = (nameEqualToNamedBindingName && typeEqualToNamedBindingType);
+
+    if (namedBindingCompares) {
+      context.debug(`...compared the '${nominalValuePropertyString}' node property with the '${namedBindingString}' named binding.`);
+    }
+
+    return namedBindingCompares;
+  }
+
+  static name = "Parameter";
+
+  static fromNameAndType(name, type) {
+    const nominalValuePropertyString = nominalValuePropertyStringFromNameAndType(name, type),
+          string = nominalValuePropertyString,  ///
+          nominalValueProperty = new NominalValueProperty(string, type, name);
+
+    return nominalValueProperty;
+  }
+};

package/src/nonTerminalNodeMap.js

@@ -3,6 +3,7 @@
 import StepNode from "./node/step";
 import SomeNode from "./node/some";
 import TermNode from "./node/term";
+import TypeNode from "./node/type";
 import TermsNode from "./node/terms";
 import EveryNode from "./node/every";
 import LabelNode from "./node/label";
@@ -42,6 +43,7 @@ import ProcedureDeclarationNode from "./node/declaration/procedure";
 import { STEP_RULE_NAME,
          SOME_RULE_NAME,
          TERM_RULE_NAME,
+         TYPE_RULE_NAME,
          TERMS_RULE_NAME,
          EVERY_RULE_NAME,
          LABEL_RULE_NAME,
@@ -82,6 +84,7 @@ const NonTerminalNodeMap = {
   [STEP_RULE_NAME]: StepNode,
   [SOME_RULE_NAME]: SomeNode,
   [TERM_RULE_NAME]: TermNode,
+  [TYPE_RULE_NAME]: TypeNode,
   [TERMS_RULE_NAME]: TermsNode,
   [EVERY_RULE_NAME]: EveryNode,
   [LABEL_RULE_NAME]: LabelNode,

package/src/preamble.js

@@ -3,6 +3,7 @@
 import Step from "./element/step";
 import Some from "./element/some";
 import Term from "./element/term";
+import Type from "./element/type";
 import Terms from "./element/terms";
 import Label from "./element/label";
 import Error from "./element/error";

package/src/ruleNames.js

@@ -3,6 +3,7 @@
 export const STEP_RULE_NAME = "step";
 export const SOME_RULE_NAME = "some";
 export const TERM_RULE_NAME = "term";
+export const TYPE_RULE_NAME = "type";
 export const TERMS_RULE_NAME = "terms";
 export const EVERY_RULE_NAME = "every";
 export const LABEL_RULE_NAME = "label";

package/src/typeNames.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export const LIST_TYPE_NAME = "List";
+export const STRING_TYPE_NAME = "String";
+export const NUMBER_TYPE_NAME = "Number";
+export const BOOLEAN_TYPE_NAME = "Boolean";
+export const NOMINAL_VALUE_TYPE_NAME = "Node"; ///