occam-furtle 2.0.120 → 2.0.121

package/src/dom/parameters/named.js

@@ -39,17 +39,17 @@ export default domAssigned(class NamedParameters {
 
   forEachNamedParameter(callback) { this.array.forEach(callback); }
 
-  matchValues(values, context) {
-    const valuesString = values.getString(),
+  matchExpressions(expressions, context) {
+    const expressionsString = expressions.getString(),
           namedParametersString = this.string; ///
 
-    context.trace(`Matching the ${valuesString} values against the '${namedParametersString}' named parameters...`);
+    context.trace(`Matching the ${expressionsString} expressions against the '${namedParametersString}' named parameters...`);
 
-    const valuesLength = values.getLength(),
+    const expressionsLength = expressions.getLength(),
           namedParametersLength = this.getLength();
 
-    if (valuesLength !== namedParametersLength) {
-      const message = `The ${valuesString} values and '${namedParametersString}' named parameters are not of the same length.`,
+    if (expressionsLength !== namedParametersLength) {
+      const message = `The ${expressionsString} expressions and '${namedParametersString}' named parameters are not of the same length.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -57,13 +57,13 @@ export default domAssigned(class NamedParameters {
 
     this.forEachNamedParameter((namedParameter, index) => {
       if (namedParameter !== null) {
-        const value = values.getValue(index);
+        const expression = expressions.getExpression(index);
 
-        namedParameter.matchValue(value, context);
+        namedParameter.matchExpression(expression, context);
       }
     });
 
-    context.debug(`...matched the ${valuesString} values against the '${namedParametersString}' named parameters.`);
+    context.debug(`...matched the ${expressionsString} expressions against the '${namedParametersString}' named parameters.`);
   }
 
   matchNamedParameter(namedParameter, context) {

package/src/dom/parameters.js

@@ -40,17 +40,17 @@ export default domAssigned(class Parameters {
 
   forEachParameter(callback) { this.array.forEach(callback); }
 
-  matchValues(values, context) {
-    const valuesString = values.getString(),
+  matchExpressions(expressions, context) {
+    const expressionsString = expressions.getString(),
           parametersString = this.string; ///
 
-    context.trace(`Matching the ${valuesString} values against the '${parametersString}' parameters...`);
+    context.trace(`Matching the ${expressionsString} expressions against the '${parametersString}' parameters...`);
 
-    const valuesLength = values.getLength(),
+    const expressionsLength = expressions.getLength(),
           parametersLength = this.getLength();
 
-    if (valuesLength !== parametersLength) {
-      const message = `The ${valuesString} values and '${parametersString}' parameters are not of the same length.`,
+    if (expressionsLength !== parametersLength) {
+      const message = `The ${expressionsString} expressions and '${parametersString}' parameters are not of the same length.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -58,13 +58,13 @@ export default domAssigned(class Parameters {
 
     this.forEachParameter((parameter, index) => {
       if (parameter !== null) {
-        const value = values.getValue(index);
+        const expression = expressions.getExpression(index);
 
-        parameter.matchValue(value, context);
+        parameter.matchExpression(expression, context);
       }
     });
 
-    context.debug(`...matched the ${valuesString} values against the '${parametersString}' parameters.`);
+    context.debug(`...matched the ${expressionsString} expressions against the '${parametersString}' parameters.`);
   }
 
   static name = "Parameters";

package/src/dom/procedure/anonymous.js

@@ -5,7 +5,7 @@ import Exception from "../../exception";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { variablesFromValuesAndParameters } from "../procedure";
+import { variablesFromExpressionsAndParameters } from "../procedure";
 
 const typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
       someAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure"),
@@ -36,20 +36,20 @@ export default domAssigned(class AnonymousProcedure {
     return this.returnBlock;
   }
 
-  call(values, context) {
+  call(expressions, context) {
     const anonymousProcedureString = this.string; ///
 
     context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);
 
-    this.parameters.matchValues(values, context);
+    this.parameters.matchExpressions(expressions, context);
 
-    const variables = variablesFromValuesAndParameters(values, this.parameters, context),
-          value = this.returnBlock.evaluate(variables, context),
-          valueType = value.getType();
+    const variables = variablesFromExpressionsAndParameters(expressions, this.parameters, context),
+          expression = this.returnBlock.evaluate(variables, context),
+          expressionType = expression.getType();
 
-    if (this.type !== valueType) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type and the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type  do not match.`,
+    if (this.type !== expressionType) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type and the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type  do not match.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -57,7 +57,7 @@ export default domAssigned(class AnonymousProcedure {
 
     context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);
 
-    return value;
+    return expression;
   }
 
   static name = "AnonymousProcedure";

package/src/dom/procedure.js

@@ -47,7 +47,7 @@ export default domAssigned(class Procedure {
 
   matchName(name) { return this.label.matchName(name); }
 
-  call(values, fileContext) {
+  call(expressions, fileContext) {
     let context;
 
     context = fileContext;  ///
@@ -56,15 +56,15 @@ export default domAssigned(class Procedure {
 
     context.trace(`Calling the '${procedureString}' procedure...`);
 
-    this.parameters.matchValues(values, context);
+    this.parameters.matchExpressions(expressions, context);
 
-    const variables = variablesFromValuesAndParameters(values, this.parameters, context),
-          value = this.returnBlock.evaluate(variables, context),
-          valueType = value.getType();
+    const variables = variablesFromExpressionsAndParameters(expressions, this.parameters, context),
+          expression = this.returnBlock.evaluate(variables, context),
+          expressionType = expression.getType();
 
-    if (this.type !== valueType) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type and the '${procedureString}' procedure's '${this.type}' type  do not match.`,
+    if (this.type !== expressionType) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type and the '${procedureString}' procedure's '${this.type}' type  do not match.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -74,7 +74,7 @@ export default domAssigned(class Procedure {
 
     context.debug(`...called the '${procedureString}' procedure.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Procedure";
@@ -86,15 +86,15 @@ export default domAssigned(class Procedure {
   }
 });
 
-export function variablesFromValuesAndParameters(values, parameters, context) {
+export function variablesFromExpressionsAndParameters(expressions, parameters, context) {
   const variables = [];
 
-  values.forEachValue((value, index) => {
+  expressions.forEachExpression((expression, index) => {
     const { Variable } = dom,
           parameter = parameters.getParameter(index);
 
     if (parameter !== null) {
-      const variable = Variable.fromValueAndParameter(value, parameter, context);
+      const variable = Variable.fromExpressionAndParameter(expression, parameter, context);
 
       variables.push(variable);
     }

package/src/dom/procedureCall.js

@@ -6,13 +6,13 @@ import Exception from "../exception";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const valueProcedureCallNodeQuery = nodeQuery("/value/procedureCall");
+const expressionProcedureCallNodeQuery = nodeQuery("/expression/procedureCall");
 
 export default domAssigned(class ProcedureCall {
-  constructor(string, reference, values) {
+  constructor(string, reference, expressions) {
     this.string = string;
     this.reference = reference;
-    this.values = values;
+    this.expressions = expressions;
   }
 
   getString() {
@@ -23,8 +23,8 @@ export default domAssigned(class ProcedureCall {
     return this.reference;
   }
 
-  getValues() {
-    return this.values;
+  getExpressions() {
+    return this.expressions;
   }
 
   evaluate(context) {
@@ -43,23 +43,23 @@ export default domAssigned(class ProcedureCall {
 
     const fileContext = context.getFileContext(),
           procedure = context.findProcedureByReference(this.reference),
-          values = this.values.evaluate(context),
-          value = procedure.call(values, fileContext);
+          expressions = this.expressions.evaluate(context),
+          expression = procedure.call(expressions, fileContext);
 
     context.debug(`...evaluated the '${procedureCallString}' procedure call.`);
 
-    return value;
+    return expression;
   }
 
   static name = "ProcedureCall";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let procedureCall = null;
 
-    const valueProcedureCallNode = valueProcedureCallNodeQuery(valueNode);
+    const expressionProcedureCallNode = expressionProcedureCallNodeQuery(expressionNode);
 
-    if (valueProcedureCallNode !== null) {
-      const procedureCallNode = valueProcedureCallNode; ///
+    if (expressionProcedureCallNode !== null) {
+      const procedureCallNode = expressionProcedureCallNode; ///
 
       procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
@@ -69,19 +69,19 @@ export default domAssigned(class ProcedureCall {
 });
 
 function procedureCallFromProcedureCallNode(procedureCallNode, context) {
-  const { Values, Reference, ProcedureCall } = dom,
+  const { Reference, Expressions, ProcedureCall } = dom,
         reference = Reference.fromProcedureCallNode(procedureCallNode, context),
-        values = Values.fromProcedureCallNode(procedureCallNode, context),
-        string = stringFromValuesAndReference(values, reference, context),
-        procedureCall = new ProcedureCall(string, reference, values);
+        expressions = Expressions.fromProcedureCallNode(procedureCallNode, context),
+        string = stringFromExpressionsAndReference(expressions, reference, context),
+        procedureCall = new ProcedureCall(string, reference, expressions);
 
   return procedureCall;
 }
 
-function stringFromValuesAndReference(values, reference, context) {
-  const valuesString = values.getString(),
+function stringFromExpressionsAndReference(expressions, reference, context) {
+  const expressionsString = expressions.getString(),
         referenceString = reference.getString(),
-        string = `${referenceString}(${valuesString})`;
+        string = `${referenceString}(${expressionsString})`;
 
   return string;
 }

package/src/dom/query/node.js

@@ -14,7 +14,7 @@ import { domAssigned } from "../../dom";
 const { first } = arrayUtilities,
       { trimDoubleQuotes } = contentUtilities;
 
-const valueNodeQueryNodeQuery = nodeQuery("/value/nodeQuery"),
+const expressionNodeQueryNodeQuery = nodeQuery("/expression/nodeQuery"),
       stringLiteralTerminalNodeQuery = nodeQuery("/nodeQuery/@string-literal");
 
 export default domAssigned(class NodeQuery {
@@ -37,7 +37,7 @@ export default domAssigned(class NodeQuery {
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const nodeQueryString = this.string;  ///
 
@@ -50,23 +50,23 @@ export default domAssigned(class NodeQuery {
       throw exception;
     }
 
-    value = this.variable.evaluate(context);
+    expression = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const expressionType = expression.getType();
 
-    if (valueType !== NODE_TYPE) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type should be '${NODE_TYPE}'.`,
+    if (expressionType !== NODE_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODE_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const valueNode = value.getNode();
+    const expressionNode = expression.getNode();
 
-    if (valueNode === null) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's node is null.`,
+    if (expressionNode === null) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's node is null.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -74,7 +74,7 @@ export default domAssigned(class NodeQuery {
 
     let node;
 
-    node = valueNode; ///
+    node = expressionNode; ///
 
     const nodes = this.query.execute(node),
           nodesLength = nodes.length;
@@ -90,24 +90,24 @@ export default domAssigned(class NodeQuery {
 
     node = firstNode; ///
 
-    const { Value } = dom;
+    const { Expression } = dom;
 
-    value = Value.fromNode(node, context);
+    expression = Expression.fromNode(node, context);
 
     context.debug(`...evaluated the '${nodeQueryString}' node query.`);
 
-    return value;
+    return expression;
   }
 
   static name = "NodeQuery";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let nodeQuery = null;
 
-    const valueNodeQueryNode = valueNodeQueryNodeQuery(valueNode);
+    const expressionNodeQueryNode = expressionNodeQueryNodeQuery(expressionNode);
 
-    if (valueNodeQueryNode !== null) {
-      const nodeQueryNode = valueNodeQueryNode; ///
+    if (expressionNodeQueryNode !== null) {
+      const nodeQueryNode = expressionNodeQueryNode; ///
 
       nodeQuery = nodeQueryFromNodeQueryNode(nodeQueryNode, context);
     }

package/src/dom/query/nodes.js

@@ -12,7 +12,7 @@ import { domAssigned } from "../../dom";
 
 const { trimDoubleQuotes } = contentUtilities;
 
-const valueNodesQueryNodeQuery = nodeQuery("/value/nodesQuery"),
+const expressionNodesQueryNodeQuery = nodeQuery("/expression/nodesQuery"),
       stringLiteralTerminalNodesQuery = nodeQuery("/nodesQuery/@string-literal");
 
 export default domAssigned(class NodesQuery {
@@ -35,7 +35,7 @@ export default domAssigned(class NodesQuery {
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const nodesQueryString = this.string;  ///
 
@@ -48,23 +48,23 @@ export default domAssigned(class NodesQuery {
       throw exception;
     }
 
-    value = this.variable.evaluate(context);
+    expression = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const expressionType = expression.getType();
 
-    if (valueType !== NODE_TYPE) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type should be '${NODE_TYPE}'.`,
+    if (expressionType !== NODE_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODE_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const valueNode = value.getNode();
+    const expressionNode = expression.getNode();
 
-    if (valueNode === null) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's node is null.`,
+    if (expressionNode === null) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's node is null.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -72,28 +72,28 @@ export default domAssigned(class NodesQuery {
 
     let node;
 
-    node = valueNode; ///
+    node = expressionNode; ///
 
     const nodes = this.query.execute(node);
 
-    const { Value } = dom;
+    const { Expression } = dom;
 
-    value = Value.fromNodes(nodes, context);
+    expression = Expression.fromNodes(nodes, context);
 
     context.debug(`...evaluated the '${nodesQueryString}' nodes query.`);
 
-    return value;
+    return expression;
   }
 
   static name = "NodesQuery";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let nodesQuery = null;
 
-    const valueNodesQueryNode = valueNodesQueryNodeQuery(valueNode);
+    const expressionNodesQueryNode = expressionNodesQueryNodeQuery(expressionNode);
 
-    if (valueNodesQueryNode !== null) {
-      const nodesQueryNode = valueNodesQueryNode; ///
+    if (expressionNodesQueryNode !== null) {
+      const nodesQueryNode = expressionNodesQueryNode; ///
 
       nodesQuery = nodesQueryFromNodesQueryNode(nodesQueryNode, context);
     }

package/src/dom/reduce.js

@@ -7,13 +7,13 @@ import { nodeQuery } from "../utilities/query";
 import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
 
-const valueReduceNodeQuery = nodeQuery("/value/reduce"); ///
+const expressionReduceNodeQuery = nodeQuery("/expression/reduce");
 
 export default domAssigned(class Reduce {
-  constructor(string, variable, initialValue, anonymousProcedure) {
+  constructor(string, variable, initialExpression, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
-    this.initialValue = initialValue;
+    this.initialExpression = initialExpression;
     this.anonymousProcedure = anonymousProcedure;
   }
 
@@ -25,8 +25,8 @@ export default domAssigned(class Reduce {
     return this.variable;
   }
 
-  getInitialValue() {
-    return this.initialValue;
+  getInitialExpression() {
+    return this.initialExpression;
   }
 
   getAnonymousProcedure() {
@@ -34,59 +34,59 @@ export default domAssigned(class Reduce {
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const reduceString = this.getString();
 
     context.trace(`Evaluating the '${reduceString}' reduce...`);
 
-    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(),
-          initialValue = this.initialValue.evaluate(context);
+    const nodes = expression.getNodes(),
+          initialExpression = this.initialExpression.evaluate(context);
 
-    value = nodes.reduce((currentValue, node) => {
-      let value;
+    expression = nodes.reduce((currentExpression, node) => {
+      let expression;
 
-      const { Value, Values } = dom;
+      const { Expression, Expressions } = dom;
 
-      value = currentValue; ///
+      expression = currentExpression; ///
 
-      const values = Values.fromValue(value, context);
+      const expressions = Expressions.fromExpression(expression, context);
 
-      value = Value.fromNode(node, context);
+      expression = Expression.fromNode(node, context);
 
-      values.addValue(value);
+      expressions.addExpression(expression);
 
-      value = this.anonymousProcedure.call(values, context);
+      expression = this.anonymousProcedure.call(expressions, context);
 
-      return value;
-    }, initialValue);
+      return expression;
+    }, initialExpression);
 
     context.trace(`...evaluated the '${reduceString}' reduce.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Reduce";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let reduce = null;
 
-    const valueReduceNode = valueReduceNodeQuery(valueNode);
+    const expressionReduceNode = expressionReduceNodeQuery(expressionNode);
 
-    if (valueReduceNode !== null) {
-      const reduceNode = valueReduceNode; ///
+    if (expressionReduceNode !== null) {
+      const reduceNode = expressionReduceNode; ///
 
       reduce = reduceFromReduceNode(reduceNode, context);
     }
@@ -96,22 +96,22 @@ export default domAssigned(class Reduce {
 });
 
 function reduceFromReduceNode(reduceNode, context) {
-  const { Value, Reduce, Variable, AnonymousProcedure } = dom,
-        value = Value.fromReduceNode(reduceNode, context),
+  const { Reduce, Variable, Expression, AnonymousProcedure } = dom,
+        expression = Expression.fromReduceNode(reduceNode, context),
         variable = Variable.fromReduceNode(reduceNode, context),
-        initialValue = value, ///
+        initialExpression = expression, ///
         anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context),
-        string = stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure),
-        reduce = new Reduce(string, variable, initialValue, anonymousProcedure);
+        string = stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure),
+        reduce = new Reduce(string, variable, initialExpression, anonymousProcedure);
 
   return reduce;
 }
 
-function stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure) {
+function stringFromVariableInitialExpressionAndAnonymousProcedure(variable, initialExpression, anonymousProcedure) {
   const variableString = variable.getString(),
-        initialValueString = initialValue.getString(),
+        initialExpressionString = initialExpression.getString(),
         anonymousProcedureString = anonymousProcedure.getString(),
-        string = `Reduce(${variableString}, ${anonymousProcedureString}, ${initialValueString})`;
+        string = `Reduce(${variableString}, ${anonymousProcedureString}, ${initialExpressionString})`;
 
   return string;
 }