occam-furtle 2.0.120 → 2.0.122

package/src/dom/some.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
-const valueSomeNodeQuery = nodeQuery("/value/some");
+const expressionSomeNodeQuery = nodeQuery("/expression/some");
 
 export default domAssigned(class Some {
   constructor(string, variable, anonymousProcedure) {
@@ -29,69 +29,69 @@ export default domAssigned(class Some {
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const someString = this.getString();
 
     context.trace(`Evaluating the '${someString}' some...`);
 
-    value = this.variable.evaluate(context);
+    expression = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const expressionType = expression.getType();
 
-    if (valueType !== NODES_TYPE) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type should be '${NODES_TYPE}'.`,
+    if (expressionType !== NODES_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODES_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const nodes = value.getNodes(),
+    const nodes = expression.getNodes(),
           boolean = nodes.some((node) => {
-            let value;
+            let expression;
 
-            const { Value, Values } = dom;
+            const { Expression, Expressions } = dom;
 
-            value = Value.fromNode(node, context);
+            expression = Expression.fromNode(node, context);
 
-            const values = Values.fromValue(value, context);
+            const expressions = Expressions.fromExpression(expression, context);
 
-            value = this.anonymousProcedure.call(values, context);
+            expression = this.anonymousProcedure.call(expressions, context);
 
-            const valueType = value.getType();
+            const expressionType = expression.getType();
 
-            if (valueType !== BOOLEAN_TYPE) {
-              const valueString = value.asString(context),
-                    message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            if (expressionType !== BOOLEAN_TYPE) {
+              const expressionString = expression.asString(context),
+                    message = `The ${expressionString} expression's type is '${expressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
                     exception = Exception.fromMessage(message);
 
               throw exception;
             }
 
-            const boolean = value.getBoolean();
+            const boolean = expression.getBoolean();
 
             return boolean;
           });
 
-    const { Value } = dom;
+    const { Expression } = dom;
 
-    value = Value.fromBoolean(boolean, context);
+    expression = Expression.fromBoolean(boolean, context);
 
     context.trace(`...evaluated the '${someString}' some.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Some";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let some = null;
 
-    const valueSomeNode = valueSomeNodeQuery(valueNode);
+    const expressionSomeNode = expressionSomeNodeQuery(expressionNode);
 
-    if (valueSomeNode !== null) {
-      const someNode = valueSomeNode; ///
+    if (expressionSomeNode !== null) {
+      const someNode = expressionSomeNode; ///
 
       some = someFromSomeNode(someNode, context);
     }

package/src/dom/statement/return.js

@@ -8,31 +8,31 @@ import { domAssigned } from "../../dom";
 const returnBlockReturnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 
 export default domAssigned(class ReturnStatement {
-  constructor(string, value) {
+  constructor(string, expression) {
     this.string = string;
-    this.value = value;
+    this.expression = expression;
   }
 
   getString() {
     return this.string;
   }
 
-  getValue() {
-    return this.value;
+  getExpression() {
+    return this.expression;
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const returnStatementString = this.string;  ///
 
     context.trace(`Evaluating the '${returnStatementString}' return statement...`);
 
-    value = this.value.evaluate(context);
+    expression = this.expression.evaluate(context);
 
     context.debug(`...evaluated the '${returnStatementString}' return statement.`);
 
-    return value;
+    return expression;
   }
 
   static name = "ReturnStatement";
@@ -47,17 +47,17 @@ export default domAssigned(class ReturnStatement {
 });
 
 function returnStatementFromReturnStatementNode(returnStatementNode, context) {
-  const { Value, ReturnStatement } = dom,
-        value = Value.fromReturnStatementNode(returnStatementNode, context),
-        string = stringFromValue(value, context),
-        returnStatement = new ReturnStatement(string, value);
+  const { Expression, ReturnStatement } = dom,
+        expression = Expression.fromReturnStatementNode(returnStatementNode, context),
+        string = stringFromExpression(expression, context),
+        returnStatement = new ReturnStatement(string, expression);
 
   return returnStatement;
 }
 
-function stringFromValue(value, context) {
-  const valueString = value.asString(context),
-        string = `Return ${valueString};`;
+function stringFromExpression(expression, context) {
+  const expressionString = expression.asString(context),
+        string = `Return ${expressionString};`;
 
   return string;
 }

package/src/dom/ternary.js

@@ -7,73 +7,73 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
-const ifValueNodeQuery = nodeQuery("/ternary/value[1]"),
-      elseValueNodeQuery = nodeQuery("/ternary/value[2]"),
-      valueTernaryNodeQuery = nodeQuery("/value/ternary");
+const ifExpressionNodeQuery = nodeQuery("/ternary/expression[1]"),
+      elseExpressionNodeQuery = nodeQuery("/ternary/expression[2]"),
+      expressionTernaryNodeQuery = nodeQuery("/expression/ternary");
 
 export default domAssigned(class Ternary {
-  constructor(string, value, ifValue, elseValue) {
+  constructor(string, expression, ifExpression, elseExpression) {
     this.string = string;
-    this.value = value;
-    this.ifValue = ifValue;
-    this.elseValue = elseValue;
+    this.expression = expression;
+    this.ifExpression = ifExpression;
+    this.elseExpression = elseExpression;
   }
 
   getString() {
     return this.string;
   }
 
-  getValue() {
-    return this.value;
+  getExpression() {
+    return this.expression;
   }
 
   getIfBlock() {
-    return this.ifValue;
+    return this.ifExpression;
   }
 
   getElseBlock() {
-    return this.elseValue;
+    return this.elseExpression;
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const ternaryString = this.string; ///
 
     context.trace(`Evaluating the '${ternaryString}' ternary...`);
 
-    value = this.value.evaluate(context);
+    expression = this.expression.evaluate(context);
 
-    const valueType = value.getType();
+    const expressionType = expression.getType();
 
-    if (valueType !== BOOLEAN_TYPE) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+    if (expressionType !== BOOLEAN_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's type is '${expressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const boolean = value.getBoolean();
+    const boolean = expression.getBoolean();
 
-    value = boolean ?
-              this.ifValue.evaluate(context) :
-                this.elseValue.evaluate(context);
+    expression = boolean ?
+              this.ifExpression.evaluate(context) :
+                this.elseExpression.evaluate(context);
 
     context.debug(`...evaluated the '${ternaryString}' ternary.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Ternary";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let ternary = null;
 
-    const valueTernaryNode = valueTernaryNodeQuery(valueNode);
+    const expressionTernaryNode = expressionTernaryNodeQuery(expressionNode);
 
-    if (valueTernaryNode !== null) {
-      const ternaryNode = valueTernaryNode; ///
+    if (expressionTernaryNode !== null) {
+      const ternaryNode = expressionTernaryNode; ///
 
       ternary = ternaryFromTernaryNode(ternaryNode, context);
     }
@@ -83,23 +83,23 @@ export default domAssigned(class Ternary {
 });
 
 function ternaryFromTernaryNode(ternaryNode, context) {
-  const { Value, Ternary } = dom,
-        ifValueNode = ifValueNodeQuery(ternaryNode),
-        elseValueNode = elseValueNodeQuery(ternaryNode),
-        value = Value.fromTernaryNode(ternaryNode, context),
-        ifValue = Value.fromValueNode(ifValueNode, context),
-        elseValue = Value.fromValueNode(elseValueNode, context),
-        string = stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context),
-        ternary = new Ternary(string, value, ifValue, elseValue);
+  const { Expression, Ternary } = dom,
+        ifExpressionNode = ifExpressionNodeQuery(ternaryNode),
+        elseExpressionNode = elseExpressionNodeQuery(ternaryNode),
+        expression = Expression.fromTernaryNode(ternaryNode, context),
+        ifExpression = Expression.fromExpressionNode(ifExpressionNode, context),
+        elseExpression = Expression.fromExpressionNode(elseExpressionNode, context),
+        string = stringFromExpressionIfExpressionAndElseExpression(expression, ifExpression, elseExpression, context),
+        ternary = new Ternary(string, expression, ifExpression, elseExpression);
 
   return ternary;
 }
 
-function stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context) {
-  const valueString = value.asString(context),
-        ifValueString = ifValue.asString(context),
-        elseValueString = elseValue.asString(context),
-        string = `If (${valueString}) ${ifValueString} Else ${elseValueString};`;
+function stringFromExpressionIfExpressionAndElseExpression(expression, ifExpression, elseExpression, context) {
+  const expressionString = expression.asString(context),
+        ifExpressionString = ifExpression.asString(context),
+        elseExpressionString = elseExpression.asString(context),
+        string = `If (${expressionString}) ${ifExpressionString} Else ${elseExpressionString};`;
 
   return string;
 }

package/src/dom/variable.js

@@ -7,10 +7,10 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
 const someVariableNodeQuery = nodeQuery("/some/variable"),
-      valueVariableNodeQuery = nodeQuery("/value/variable"),
       everyVariableNodeQuery = nodeQuery("/every/variable"),
       reduceVariableNodeQuery = nodeQuery("/reduce/variable"),
       nodeQueryVariableNodeQuery = nodeQuery("/nodeQuery/variable"),
+      expressionVariableNodeQuery = nodeQuery("/expression/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
@@ -18,11 +18,11 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
 
 export default domAssigned(class Variable {
-  constructor(string, type, name, value) {
+  constructor(string, type, name, expression) {
     this.string = string;
     this.type = type;
     this.name = name;
-    this.value = value;
+    this.expression = expression;
   }
 
   getString() {
@@ -37,8 +37,8 @@ export default domAssigned(class Variable {
     return this.name;
   }
 
-  getValue() {
-    return this.value;
+  getExpression() {
+    return this.expression;
   }
 
   matchVariableName(variableName) {
@@ -64,22 +64,22 @@ export default domAssigned(class Variable {
     }
 
     const variable = context.findVariableByVariableName(variableName),
-          value = variable.getValue(),
-          valueString = value.asString(context);
+          expression = variable.getExpression(),
+          expressionString = expression.asString(context);
 
-    context.debug(`...evaluated the '${variableString}' variable to the ${valueString} value.`);
+    context.debug(`...evaluated the '${variableString}' variable to the ${expressionString} expression.`);
 
-    return value;
+    return expression;
   }
 
-  assign(value, context) {
+  assign(expression, context) {
     const nested = false,
-          valueString = value.asString(context), ///
+          expressionString = expression.asString(context), ///
           variableName = this.name, ///
           variableString = this.string, ///
           variablePresent = context.isVariablePresentByVariableName(variableName, nested);
 
-    context.trace(`Assigning the ${valueString} value to the '${variableString}' variable...`);
+    context.trace(`Assigning the ${expressionString} expression to the '${variableString}' variable...`);
 
     if (variablePresent) {
       const message = `The '${variableString}' variable is already present.`,
@@ -88,23 +88,23 @@ export default domAssigned(class Variable {
       throw exception;
     }
 
-    const valueType = value.getType(),
+    const expressionType = expression.getType(),
           variableType = this.type;
 
-    if (valueType !== variableType) {
-      const message = `The '${variableString} variable's '${variableType}' type does not match the value's '${valueType}' type.'`,
+    if (expressionType !== variableType) {
+      const message = `The '${variableString} variable's '${variableType}' type does not match the expression's '${expressionType}' type.'`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    this.value = value;
+    this.expression = expression;
 
     const variable = this;  ///
 
     context.addVariable(variable);
 
-    context.debug(`...assigned the ${valueString} value to the '${variableString}' variable.`);
+    context.debug(`...assigned the ${expressionString} expression to the '${variableString}' variable.`);
   }
 
   static name = "Variable";
@@ -117,13 +117,13 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let variable = null;
 
-    const valueVariableNode = valueVariableNodeQuery(valueNode);
+    const expressionVariableNode = expressionVariableNodeQuery(expressionNode);
 
-    if (valueVariableNode !== null) {
-      const variableNode = valueVariableNode; ///
+    if (expressionVariableNode !== null) {
+      const variableNode = expressionVariableNode; ///
 
       variable = variableFromVariableNode(variableNode, context);
     }
@@ -142,9 +142,9 @@ export default domAssigned(class Variable {
   static fromParameter(parameter, context) {
     const type = parameter.getType(),
           name = parameter.getName(),
-          value = null,
+          expression = null,
           string = stringFromName(name, context),
-          variable = new Variable(string, type, name, value);
+          variable = new Variable(string, type, name, expression);
 
     return variable;
   }
@@ -179,18 +179,18 @@ export default domAssigned(class Variable {
           name = (asName !== null) ?
                    asName : ///
                      namedParameter.getName(),
-          value = null,
+          expression = null,
           string = stringFromName(name, context),
-          variable = new Variable(string, type, name, value);
+          variable = new Variable(string, type, name, expression);
 
     return variable;
   }
 
-  static fromValueAndParameter(value, parameter, context) {
+  static fromExpressionAndParameter(expression, parameter, context) {
     const type = parameter.getType(),
           name = parameter.getName(),
           string = stringFromName(name, context),
-          variable = new Variable(string, type, name, value);
+          variable = new Variable(string, type, name, expression);
 
     return variable;
   }
@@ -223,9 +223,9 @@ export default domAssigned(class Variable {
 function variableFromTypeAndVariableNode(type, variableNode, context) {
   const { Variable } = dom,
         name = nameFromVariableNode(variableNode),
-        value = null,
+        expression = null,
         string = stringFromName(name, context),
-        variable = new Variable(string, type, name, value);
+        variable = new Variable(string, type, name, expression);
 
   return variable;
 }
@@ -234,9 +234,9 @@ function variableFromVariableNode(variableNode, context) {
   const { Variable } = dom,
         type = null,
         name = nameFromVariableNode(variableNode),
-        value = null,
+        expression = null,
         string = stringFromName(name, context),
-        variable = new Variable(string, type, name, value);
+        variable = new Variable(string, type, name, expression);
 
   return variable;
 }

package/src/example/utilities/{values.js → expressions.js}

@@ -1,7 +1,7 @@
 "use strict";
 
 import { Query } from "occam-query";
-import { Values } from "../../index"; ///
+import { Expressions } from "../../index"; ///
 import { arrayUtilities } from "necessary";
 
 const { first } = arrayUtilities;
@@ -9,12 +9,12 @@ const { first } = arrayUtilities;
 const freeTermNodeQuery = Query.fromExpressionString("//term[1]"),
       boundTermNodeQuery = Query.fromExpressionString("//term[0]");
 
-export function valuesFromFileContext(fileContext, free = true) {
+export function expressionsFromFileContext(fileContext, free = true) {
   const context = fileContext,  ///
         nodes = nodesFromFileContext(fileContext, free),
-        values = Values.fromNodes(nodes, context);
+        expressions = Expressions.fromNodes(nodes, context);
 
-  return values;
+  return expressions;
 }
 
 function nodesFromFileContext(fileContext, free) {

package/src/example.js

@@ -5,7 +5,7 @@ import "./index";
 import { ReleaseContext } from "./example/context/release";
 
 import { furtleFileFromNothing } from "./example/utilities/furtle";
-import { valuesFromFileContext } from "./example/utilities/values";
+import { expressionsFromFileContext } from "./example/utilities/expressions";
 import { procedureFromReleaseContext } from "./example/utilities/procedure";
 import { nominalFileContextFromReleaseContext } from "./example/utilities/nominal";
 
@@ -23,12 +23,12 @@ const nominalFileContext = nominalFileContextFromReleaseContext(releaseContext),
 releaseContext.addFileContext(fileContext);
 
 const free = true,
-      values = valuesFromFileContext(fileContext, free),
+      expressions = expressionsFromFileContext(fileContext, free),
       procedure = procedureFromReleaseContext(releaseContext);
 
 // try {
-  const value = procedure.call(values, fileContext),
-        boolean = value.getBoolean();
+  const expression = procedure.call(expressions, fileContext),
+        boolean = expression.getBoolean();
 
   console.log(boolean);
 // } catch (exception) {

package/src/index.js

@@ -4,9 +4,7 @@ import Step from "./dom/step";
 import Some from "./dom/some";
 import Label from "./dom/label";
 import Error from "./dom/error";
-import Value from "./dom/value";
 import Every from "./dom/every";
-import Values from "./dom/values";
 import Reduce from "./dom/reduce";
 import Ternary from "./dom/ternary";
 import Variable from "./dom/variable";
@@ -17,21 +15,23 @@ import Parameter from "./dom/parameter";
 import Parameters from "./dom/parameters";
 import NodesQuery from "./dom/query/nodes";
 import Comparison from "./dom/comparison";
+import Expression from "./dom/expression";
+import Expressions from "./dom/expressions";
 import ReturnBlock from "./dom/block/return";
-import NegatedValue from "./dom/value/negated";
-import BitwiseValue from "./dom/value/bitwise";
 import ProcedureCall from "./dom/procedureCall";
 import NamedParameter from "./dom/parameter/named";
-import BracketedValue from "./dom/value/bracketed";
 import ArrayAssigment from "./dom/assignment/array";
 import ReturnStatement from "./dom/statement/return";
 import NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
+import NegatedExpression from "./dom/expression/negated";
+import BitwiseExpression from "./dom/expression/bitwise";
 import AnonymousProcedure from "./dom/procedure/anonymous";
 import VariableAssignment from "./dom/assignment/variable";
+import BracketedExpression from "./dom/expression/bracketed";
 import VariableAssignments from "./dom/assignments/variable";
 import ProcedureDeclaration from "./dom/declaration/procedure";
 
-export { default as Values } from "./dom/values";
+export { default as Expressions } from "./dom/expressions";
 export { default as FileContext } from "./context/file";
 export { default as stringUtilities } from "./utilities/string";