occam-furtle 2.0.80 → 2.0.82

package/src/dom/reduce.js

@@ -7,14 +7,16 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
-const variableNodeQuery = nodeQuery("/some/variable"),
-      valueSomeNodeQuery = nodeQuery("/value/some"),
-      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
+const variableNodeQuery = nodeQuery("/reduce/variable"),
+      parametersNodeQuery = nodeQuery("/reduce/anonymousProcedure/parameters"),
+      valueReduceNodeQuery = nodeQuery("/value/reduce"),
+      initialValueNodeQuery = nodeQuery("/reduce/value"); ///
 
-export default domAssigned(class Some {
-  constructor(string, variable, anonymousProcedure) {
+export default domAssigned(class Reduce {
+  constructor(string, variable, initialValue, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
+    this.initialValue = initialValue;
     this.anonymousProcedure = anonymousProcedure;
   }
 
@@ -26,6 +28,10 @@ export default domAssigned(class Some {
     return this.variable;
   }
 
+  getInitialValue() {
+    return this.initialValue;
+  }
+
   getAnonymousProcedure() {
     return this.anonymousProcedure;
   }
@@ -33,9 +39,9 @@ export default domAssigned(class Some {
   evaluate(context) {
     let value;
 
-    const someString = this.getString();
+    const reduceString = this.getString();
 
-    context.trace(`Evaluating the '${someString}' some...`);
+    context.trace(`Evaluating the '${reduceString}' reduce...`);
 
     value = this.variable.evaluate(context);
 
@@ -50,68 +56,62 @@ export default domAssigned(class Some {
     }
 
     const nodes = value.getNodes(),
-          boolean = nodes.some((node) => {
-            let value;
-
-            const { Value, Values } = dom;
-
-            value = Value.fromNode(node, context);
-
-            const values = Values.fromValue(value, context);
+          initialValue = this.initialValue.evaluate(context);
 
-            value = this.anonymousProcedure.call(values, context);
+    value = nodes.reduce((currentValue, node) => {
+      let value;
 
-            const valueType = value.getType();
+      const { Value, Values } = dom;
 
-            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}'.`,
-                    exception = Exception.fromMessage(message);
+      value = currentValue; ///
 
-              throw exception;
-            }
+      const values = Values.fromValue(value, context);
 
-            const boolean = value.getBoolean();
+      value = Value.fromNode(node, context);
 
-            return boolean;
-          });
+      values.addValue(value);
 
-    const { Value } = dom;
+      value = this.anonymousProcedure.call(values, context);
 
-    value = Value.fromBoolean(boolean, context);
+      return value;
+    }, initialValue);
 
-    context.trace(`...evaluated the '${someString}' some.`);
+    context.trace(`...evaluated the '${reduceString}' reduce.`);
 
     return value;
   }
 
-  static name = "Some";
+  static name = "Reduce";
 
   static fromValueNode(valueNode, context) {
-    let some = null;
+    let reduce = null;
 
-    const valueSomeNode = valueSomeNodeQuery(valueNode);
+    const valueReduceNode = valueReduceNodeQuery(valueNode);
 
-    if (valueSomeNode !== null) {
-      const { Variable, AnonymousProcedure } = dom,
-            someNode = valueSomeNode, ///
-            string = stringFromSomeNode(someNode, context),
-            variable = Variable.fromSomeNode(someNode, context),
-            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context);
+    if (valueReduceNode !== null) {
+      const { Value, Variable, AnonymousProcedure } = dom,
+            reduceNode = valueReduceNode, ///
+            string = stringFromReduceNode(reduceNode, context),
+            value = Value.fromReduceNode(reduceNode, context),
+            variable = Variable.fromReduceNode(reduceNode, context),
+            initialValue = value, ///
+            anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context);
 
-      some = new Some(string, variable, anonymousProcedure);
+      reduce = new Reduce(string, variable, initialValue, anonymousProcedure);
     }
 
-    return some;
+    return reduce;
   }
 });
 
-function stringFromSomeNode(someNode, context) {
-  const variableNode = variableNodeQuery(someNode),
-        parametersNode = parametersNodeQuery(someNode),
+function stringFromReduceNode(reduceNode, context) {
+  const variableNode = variableNodeQuery(reduceNode),
+        parametersNode = parametersNodeQuery(reduceNode),
+        initialValueNode = initialValueNodeQuery(reduceNode),
         variableString = context.nodeAsString(variableNode),
         parametersString = context.nodeAsString(parametersNode),
-        string = `Some(${variableString}, (${parametersString}) { ... })`;
+        initialValueString = context.nodeAsString(initialValueNode),
+        string = `Reduce(${variableString}, (${parametersString}) { ... }, ${initialValueString})`;
 
   return string;
 }

package/src/dom/statement/return.js

@@ -40,11 +40,17 @@ export default domAssigned(class ReturnStatement {
   static fromReturnBlockNode(returnBlockNode, context) {
     const { Value } = dom,
           returnStatementNode = returnStatementNodeQuery(returnBlockNode),
-          node = returnStatementNode, ///
-          string = context.nodeAsString(node),
           value = Value.fromReturnStatementNode(returnStatementNode, context),
+          string = stringFromValue(value, context),
           returnStatement = new ReturnStatement(string, value);
 
     return returnStatement;
   }
 });
+
+function stringFromValue(value, context) {
+  const valueString = value.asString(context),
+        string = `Return ${valueString};`;
+
+  return string;
+}

package/src/dom/ternary.js

@@ -7,8 +7,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
-const valueNodeQuery = nodeQuery("/ternary/value[0]"),
-      ifValueNodeQuery = nodeQuery("/ternary/value[1]"),
+const ifValueNodeQuery = nodeQuery("/ternary/value[1]"),
       ternaryNodeQuery = nodeQuery("/value/ternary"),
       elseValueNodeQuery = nodeQuery("/ternary/value[2]");
 
@@ -75,12 +74,12 @@ export default domAssigned(class Ternary {
 
     if (ternaryNode !== null) {
       const { Value } = dom,
-            string = stringFromTernaryNode(ternaryNode, context),
             ifValueNode = ifValueNodeQuery(ternaryNode),
             elseValueNode = elseValueNodeQuery(ternaryNode),
             value = Value.fromTernaryNode(ternaryNode, context),
             ifValue = Value.fromValueNode(ifValueNode, context),
-            elseValue = Value.fromValueNode(elseValueNode, context);
+            elseValue = Value.fromValueNode(elseValueNode, context),
+            string = stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context);
 
       ternary = new Ternary(string, value, ifValue, elseValue);
     }
@@ -89,17 +88,11 @@ export default domAssigned(class Ternary {
   }
 });
 
-function stringFromTernaryNode(ternaryNode, context) {
-  let string;
-
-  const valueNode = valueNodeQuery(ternaryNode),
-        ifValueNode = ifValueNodeQuery(ternaryNode),
-        elseValueNode = elseValueNodeQuery(ternaryNode),
-        ifValueString = context.nodeAsString(ifValueNode),
-        elseValueString = context.nodeAsString(elseValueNode),
-        valueString = context.nodeAsString(valueNode);
-
-  string = `If (${valueString}) ${ifValueString} ${elseValueString}`;
+function stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context) {
+  const valueString = value.getString(),
+        ifValueString = ifValue.getString(),
+        elseValueString = elseValue.getString(),
+        string = `If (${valueString}) ${ifValueString} ${elseValueString}`;
 
   return string;
 }

package/src/dom/value/bitwise.js

@@ -5,8 +5,8 @@ import Exception from "../../exception";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { DISJUNCTION } from "../../constants";
 import { BOOLEAN_TYPE } from "../../types";
+import { CONJUNCTION, DISJUNCTION } from "../../constants";
 
 const terminalNodeQuery = nodeQuery("/bitwiseValue/@*"),
       leftValueNodeQuery = nodeQuery("/bitwiseValue/value[0]"),
@@ -93,14 +93,13 @@ export default domAssigned(class BitwiseValue {
 
     if (bitwiseValueNode !== null) {
       const { Value } = dom,
-            node = bitwiseValueNode,  //
-            string = context.nodeAsString(node),
             type = BOOLEAN_TYPE,
             leftValueNode = leftValueNodeQuery(bitwiseValueNode),
             rightValueNode = rightValueNodeQuery(bitwiseValueNode),
             disjoint = disjointFromBitwiseValueNode(bitwiseValueNode, context),
             leftValue = Value.fromValueNode(leftValueNode, context),
-            rightValue = Value.fromValueNode(rightValueNode, context);
+            rightValue = Value.fromValueNode(rightValueNode, context),
+            string = stringFromTypeDisjointLeftValueAndRightValue(disjoint, leftValue, rightValue, context);
 
       bitwiseValue = new BitwiseValue(string, type, disjoint, leftValue, rightValue);
     }
@@ -116,3 +115,14 @@ function disjointFromBitwiseValueNode(bitwiseValueNode, context) {
 
   return disjoint;
 }
+
+function stringFromTypeDisjointLeftValueAndRightValue(disjoint, leftValue, rightValue, context) {
+  const operatorString = disjoint ?
+                           DISJUNCTION :
+                             CONJUNCTION,
+        leftValueString = leftValue.asString(context),
+        rightValueString = rightValue.asString(context),
+        string = `${leftValueString} ${operatorString} ${rightValueString}`;
+
+  return string;
+}

package/src/dom/value/bracketed.js

@@ -48,10 +48,9 @@ export default domAssigned(class BracketedValue {
     if (valueBracketedValueNode !== null) {
       const { Value } = dom,
             bracketedValueNode = valueBracketedValueNode, ///
-            node = bracketedValueNode,  ///
-            string = context.nodeAsString(node),
             valueNode = valueNodeQuery(bracketedValueNode),
-            value = Value.fromValueNode(valueNode, context);
+            value = Value.fromValueNode(valueNode, context),
+            string = stringFromValue(value, context);
 
       bracketedValue = new BracketedValue(string, value);
     }
@@ -59,3 +58,10 @@ export default domAssigned(class BracketedValue {
     return bracketedValue;
   }
 });
+
+function stringFromValue(value, context) {
+  const valueString = value.asString(context),
+        string = `(${valueString})`;
+
+  return string;
+}

package/src/dom/value/negated.js

@@ -70,11 +70,10 @@ export default domAssigned(class NegatedValue {
 
     if (negatedValueNode !== null) {
       const { Value } = dom,
-            node = negatedValueNode,  //
-            string = context.nodeAsString(node),
             type = BOOLEAN_TYPE,
             valueNode = valueNodeQuery(negatedValueNode),
-            value = Value.fromValueNode(valueNode, context);
+            value = Value.fromValueNode(valueNode, context),
+            string = stringFromValue(value, context);
 
       negatedValue = new NegatedValue(string, type, value);
     }
@@ -82,3 +81,10 @@ export default domAssigned(class NegatedValue {
     return negatedValue;
   }
 });
+
+function stringFromValue(value, context) {
+  const valueString = value.asString(context),
+        string = `!${valueString}`;
+
+  return string;
+}

package/src/dom/value.js

@@ -12,7 +12,8 @@ import { NODE_TYPE, NODES_TYPE, NUMBER_TYPE, STRING_TYPE, BOOLEAN_TYPE } from ".
 
 const { match } = arrayUtilities;
 
-const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
+const reduceValueNodeQuery = nodeQuery("/reduce/value"),
+      ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       numberTerminalNodeQuery = nodeQuery("/value/@number"),
       conditionValueNodeQuery = nodeQuery("/condition/value"),
       primitiveTerminalNodeQuery = nodeQuery("/value/@primitive"),
@@ -29,7 +30,7 @@ export default domAssigned(class Value {
     this.string = string;
     this.boolean = boolean;
     this.some = some;
-    this.every - every;
+    this.every = every;
     this.reduce = reduce;
     this.ternary = ternary;
     this.variable = variable;
@@ -171,37 +172,37 @@ export default domAssigned(class Value {
     } else if (this.nodes !== null) {
       string = nodesAsString(this.nodes, context);
     } else if (this.number !== null) {
-      string = numberAsString(this.number, context);
+      string = numberAsString(this.number);
     } else if (this.string !== null) {
-      string = stringAsString(this.string, context)
+      string = stringAsString(this.string)
     } else if (this.boolean !== null) {
-      string = booleanAsString(this.boolean, context)
+      string = booleanAsString(this.boolean)
     } else if (this.some !== null) {
-      string = this.some.asString(context);
+      string = this.some.getString();
     } else if (this.every !== null) {
-      string = this.every.asString(context);
+      string = this.every.getString();
     } else if (this.reduce !== null) {
-      string = this.reduce.asString(context);
+      string = this.reduce.getString();
     } else if (this.ternary !== null) {
-      string = this.ternary.asString(context);
+      string = this.ternary.getString();
     } else if (this.variable !== null) {
-      string = this.variable.asString(context);
+      string = this.variable.getString();
     } else if (this.nodeQuery !== null) {
-      string = this.nodeQuery.asString(context);
+      string = this.nodeQuery.getString();
     } else if (this.nodesQuery !== null) {
-      string = this.nodesQuery.asString(context);
+      string = this.nodesQuery.getString();
     } else if (this.comparison !== null) {
-      string = this.comparison.asString(context);
+      string = this.comparison.getString();
     } else if (this.negatedValue !== null) {
-      string = this.negatedValue.asString(context);
+      string = this.negatedValue.getString();
     } else if (this.bitwiseValue !== null) {
-      string = this.bitwiseValue.asString(context);
+      string = this.bitwiseValue.getString();
     } else if (this.bracketedValue !== null) {
-      string = this.bracketedValue.asString(context);
+      string = this.bracketedValue.getString();
     } else if (this.procedureCall !== null) {
-      string = this.procedureCall.asString(context);
+      string = this.procedureCall.getString();
     } else if (this.anonymousProcedureCall !== null) {
-      string = this.anonymousProcedureCall.asString(context);
+      string = this.anonymousProcedureCall.getString();
     }
 
     return string;
@@ -401,6 +402,14 @@ export default domAssigned(class Value {
     return value;
   }
 
+  static fromReduceNode(reduceNode, context) {
+    const reduceValueNode = reduceValueNodeQuery(reduceNode),
+          valueNode = reduceValueNode, ///
+          value = valueFromValueNode(valueNode, context);
+
+    return value;
+  }
+
   static fromTernaryNode(ternaryNode, context) {
     const ternaryValueNode = ternaryValueNodeQuery(ternaryNode),
           valueNode = ternaryValueNode, ///
@@ -504,7 +513,7 @@ function nodesAsString(nodes, context) {
   return string;
 }
 
-function numberAsString(number, context) {
+function numberAsString(number) {
   let string;
 
   string = `${number}`;
@@ -512,13 +521,13 @@ function numberAsString(number, context) {
   return string;
 }
 
-function stringAsString(string, context) {
+function stringAsString(string) {
   string = `"${string}"`; ///
 
   return string;
 }
 
-function booleanAsString(boolean, context) {
+function booleanAsString(boolean) {
   let string;
 
   string = `'${boolean}'`;

package/src/dom/values.js

@@ -35,6 +35,10 @@ export default domAssigned(class Values {
     return value;
   }
 
+  addValue(value) {
+    this.array.push(value);
+  }
+
   mapValue(callback) { return this.array.map(callback); }
 
   forEachValue(callback) { this.array.forEach(callback); }

package/src/dom/variable.js

@@ -9,6 +9,7 @@ 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"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
@@ -146,6 +147,14 @@ export default domAssigned(class Variable {
     return variable;
   }
 
+  static fromReduceNode(reduceNode, context) {
+    const reduceVariableNode = reduceVariableNodeQuery(reduceNode),
+          variableNode = reduceVariableNode, ///
+          variable = variableFromVariableNode(variableNode, context);
+
+    return variable;
+  }
+
   static fromNodeQueryNode(nodeQueryNode, context) {
     const nodeQueryVariableNode = nodeQueryVariableNodeQuery(nodeQueryNode),
           variableNode = nodeQueryVariableNode, ///

package/src/nodeProperty.js

@@ -49,7 +49,7 @@ export default class NodeProperty {
   }
 };
 
-function stringFromNameAndType(name, type) {
+function stringFromNameAndType(name, type, context) {
   const string = `${type} ${name}`;
 
   return string;