occam-furtle 2.0.80 → 2.0.86

package/src/dom/parameter/named.js

@@ -80,14 +80,31 @@ export default domAssigned(class NamedParameter {
     const type = typeFromNamedParameterNode(namedParameterNode, context),
           name = nameFromNamedParameterNode(namedParameterNode, context),
           asName = asNameFromNamedParameterNode(namedParameterNode, context),
-          node = namedParameterNode, //
-          string = context.nodeAsString(node),
+          string = stringFromTypeNameAndAsName(type, name, asName, context),
           namedParameter = new NamedParameter(string, type, name, asName);
 
     return namedParameter;
   }
 });
 
+function stringFromTypeNameAndAsName(type, name, asName, context) {
+  let string;
+
+  const typeString = type,  ///
+        nameString = name;  ///
+
+  string = `${typeString} ${nameString}`;
+
+  if (asName !== null) {
+    const asNameString = asName;  ///
+
+    string = `${string} As ${asNameString}`;
+  }
+
+  return string;
+}
+
+
 function typeFromNamedParameterNode(namedParameterNode, context) {
   const typeTerminalNode = typeTerminalNodeQuery(namedParameterNode),
         typeTerminalNodeContent = typeTerminalNode.getContent(),

package/src/dom/parameter.js

@@ -57,8 +57,7 @@ export default domAssigned(class Parameter {
     if (terminalNodesLength === 2) {
       const name = nameFromParameterNode(parameterNode, context),
             type = typeFromParameterNode(parameterNode, context),
-            node = parameterNode, //
-            string = context.nodeAsString(node);
+            string = stringFromNameAndType(name, type, context);
 
       parameter = new Parameter(string, type, name);
     }
@@ -67,6 +66,14 @@ export default domAssigned(class Parameter {
   }
 });
 
+function stringFromNameAndType(name, type, context) {
+  const nameString = name,  ///
+        typeString = type,  ///
+        string = `${typeString} ${nameString}`;
+
+  return string;
+}
+
 function nameFromParameterNode(parameterNode, context) {
   const nameTerminalNode = nameTerminalNodeQuery(parameterNode),
         nameTerminalNodeContent = nameTerminalNode.getContent(),

package/src/dom/parameters/named.js

@@ -107,16 +107,30 @@ export default domAssigned(class NamedParameters {
   static fromObjectAssignmentNode(objectAssignmentNode, context) {
     const objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode),
           parametersNode = objectAssignmentNamedParametersNode,  ///
-          node = parametersNode,  ///
-          string = context.nodeAsString(node),
           namedParameterNodes = namedParameterNodesQuery(parametersNode),
           array = arrayFromNamedParameterNodes(namedParameterNodes, context),
+          string = stringFromArray(array, context),
           namedParameters = new NamedParameters(string, array);
 
     return namedParameters;
   }
 });
 
+function stringFromArray(array, context) {
+  const namedParametersSString = array.reduce((namedParametersSString, namedParameter) => {
+          const namedParameterString = namedParameter.getString();
+
+          namedParametersSString = (namedParametersSString === null) ?
+                                     namedParameterString :
+                                      `${namedParametersSString}, ${namedParameterString}`;
+
+          return namedParametersSString;
+        }, null),
+        string = namedParametersSString;  ///
+
+  return string;
+}
+
 function arrayFromNamedParameterNodes(namedParameterNodes, context) {
   const { NamedParameter } = dom,
         array = namedParameterNodes.map((namedParameterNode) => { ///

package/src/dom/parameters.js

@@ -121,7 +121,7 @@ export default domAssigned(class Parameters {
   }
 });
 
-export function stringFromArray(array, context) {
+function stringFromArray(array, context) {
   const parametersString = array.reduce((parametersString, parameter) => {
           const parameterString = parameter.getString();
 

package/src/dom/procedure/anonymous.js

@@ -7,11 +7,10 @@ import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 import { variablesFromValuesAndParameters } from "../procedure";
 
-const parametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
-      typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
+const typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
       someAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure"),
       everyAnonymousProcedureNodeQuery = nodeQuery("/every/anonymousProcedure"),
-      anonymousProcedureCallAnonymousProcedureNodeQuery = nodeQuery("/anonymousProcedureCall/anonymousProcedure");
+      reduceAnonymousProcedureNodeQuery = nodeQuery("/reduce/anonymousProcedure");
 
 export default domAssigned(class AnonymousProcedure {
   constructor(string, type, parameters, returnBlock) {
@@ -44,9 +43,8 @@ export default domAssigned(class AnonymousProcedure {
 
     this.parameters.matchValues(values, context);
 
-    const variables = variablesFromValuesAndParameters(values, this.parameters, context);
-
-    const value = this.returnBlock.evaluate(variables, context),
+    const variables = variablesFromValuesAndParameters(values, this.parameters, context),
+          value = this.returnBlock.evaluate(variables, context),
           valueType = value.getType();
 
     if (this.type !== valueType) {
@@ -80,9 +78,9 @@ export default domAssigned(class AnonymousProcedure {
     return anonymousProcedure;
   }
 
-  static fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context) {
-    const anonymousProcedureCallAnonymousProcedureNode = anonymousProcedureCallAnonymousProcedureNodeQuery(anonymousProcedureCallNode),
-          anonymousProcedureNode = anonymousProcedureCallAnonymousProcedureNode,  ///
+  static fromReduceNode(reduceNode, context) {
+    const reduceAnonymousProcedureNode = reduceAnonymousProcedureNodeQuery(reduceNode),
+          anonymousProcedureNode = reduceAnonymousProcedureNode,  ///
           anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
 
     return anonymousProcedure;
@@ -91,15 +89,24 @@ export default domAssigned(class AnonymousProcedure {
 
 function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
   const { Parameters, ReturnBlock, AnonymousProcedure } = dom,
-        string = stringFromAnonymousProcedureNode(anonymousProcedureNode, context),
-        type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
-        parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context),
         returnBlock = ReturnBlock.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
+        string = stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context),
         anonymousProcedure = new AnonymousProcedure(string, type, parameters, returnBlock);
 
   return anonymousProcedure;
 }
 
+function stringFromTypeParametersAndReturnBlock(type, parameters, returnBlock, context) {
+  const typeString = type,  ///
+        parametersString = parameters.getString(),
+        returnBlockString = returnBlock.getString(),
+        string = `${typeString} (${parametersString}) ${returnBlockString}`;
+
+  return string;
+}
+
 function typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context) {
   const typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
         typeTerminalNodeContent = typeTerminalNode.getContent(),
@@ -107,14 +114,3 @@ function typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context
 
   return type;
 }
-
-function stringFromAnonymousProcedureNode(anonymousProcedureNode, context) {
-  const parametersNode = parametersNodeQuery(anonymousProcedureNode),
-        typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
-        parametersString = context.nodeAsString(parametersNode),
-        typeNode = typeTerminalNode,  ///
-        typeString = context.nodeAsString(typeNode),
-        string = `${typeString} (${parametersString}) { ... }`;
-
-  return string;
-}

package/src/dom/procedure.js

@@ -83,11 +83,11 @@ export default domAssigned(class Procedure {
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
     const { Label, ReturnBlock, Parameters } = dom,
-          string = stringFromProcedureDeclarationNode(procedureDeclarationNode, context),
           type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
           label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),
           parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),
           returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+          string = stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
           procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
 
     return procedureDeclaration;
@@ -119,15 +119,12 @@ function typeFromProcedureDeclarationNode(procedureDeclarationNode, context) {
   return type;
 }
 
-function stringFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const labelNode = labelNodeQuery(procedureDeclarationNode),
-        parametersNode = parametersNodeQuery(procedureDeclarationNode),
-        typeTerminalNode = typeTerminalNodeQuery(procedureDeclarationNode),
-        typeNode = typeTerminalNode,  ///
-        typeString = context.nodeAsString(typeNode),
-        labelString = context.nodeAsString(labelNode),
-        parametersString = context.nodeAsString(parametersNode),
-        string = `${typeString} ${labelString}(${parametersString}) { ... }`;
+function stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock) {
+  const typeString = type,  ///
+        labelString = label.getString(),
+        parametersString = parameters.getString(),
+        returnBlockString = returnBlock.getString(),
+        string = `${typeString} ${labelString}(${parametersString}) ${returnBlockString}`;
 
   return string;
 }

package/src/dom/procedureCall.js

@@ -61,9 +61,9 @@ export default domAssigned(class ProcedureCall {
     if (procedureCallNode !== null) {
       const { Values, Reference } = dom,
             node = procedureCallNode, ///
-            string = context.nodeAsString(node),
             reference = Reference.fromValueNode(valueNode, context),
-            values = Values.fromValueNode(valueNode, context);
+            values = Values.fromValueNode(valueNode, context),
+            string = stringFromValuesAndReference(values, reference, context);
 
       procedureCall = new ProcedureCall(string, reference, values);
     }
@@ -71,3 +71,11 @@ export default domAssigned(class ProcedureCall {
     return procedureCall;
   }
 });
+
+function stringFromValuesAndReference(values, reference, context) {
+  const valuesString = values.getString(),
+        referenceString = reference.getString(),
+        string = `${referenceString}(${valuesString})`;
+
+  return string;
+}

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,59 @@ 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, ///
+            value = Value.fromReduceNode(reduceNode, context),
+            variable = Variable.fromReduceNode(reduceNode, context),
+            initialValue = value, ///
+            anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context),
+            string = stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure);
 
-      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),
-        variableString = context.nodeAsString(variableNode),
-        parametersString = context.nodeAsString(parametersNode),
-        string = `Some(${variableString}, (${parametersString}) { ... })`;
+function stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure) {
+  const variableString = variable.getString(),
+        initialValueString = initialValue.getString(),
+        anonymousProcedureString = anonymousProcedure.getString(),
+        string = `Reduce(${variableString}, ${anonymousProcedureString}, ${initialValueString})`;
 
   return string;
-}
+}

package/src/dom/reference.js

@@ -34,15 +34,21 @@ export default domAssigned(class Reference {
   static fromValueNode(valueNode, context) {
     const valueProcedureCallReferenceNod = valueProcedureCallReferenceNodeQuery(valueNode),
           referenceNode = valueProcedureCallReferenceNod,
-          node = referenceNode, ///
-          string = context.nodeAsString(node),
           name = nameFromReferenceNode(referenceNode, context),
+          string = stringFromName(name, context),
           reference = new Reference(string, name);
 
     return reference;
   }
 });
 
+function stringFromName(name, context) {
+  const nameString = name,  ///
+        string = nameString;  ///
+
+  return string;
+}
+
 function nameFromReferenceNode(referenceNode, context) {
   const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
         referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),

package/src/dom/some.js

@@ -95,9 +95,9 @@ export default domAssigned(class Some {
     if (valueSomeNode !== null) {
       const { Variable, AnonymousProcedure } = dom,
             someNode = valueSomeNode, ///
-            string = stringFromSomeNode(someNode, context),
+            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context),
             variable = Variable.fromSomeNode(someNode, context),
-            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context);
+            string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context);
 
       some = new Some(string, variable, anonymousProcedure);
     }
@@ -106,12 +106,10 @@ export default domAssigned(class Some {
   }
 });
 
-function stringFromSomeNode(someNode, context) {
-  const variableNode = variableNodeQuery(someNode),
-        parametersNode = parametersNodeQuery(someNode),
-        variableString = context.nodeAsString(variableNode),
-        parametersString = context.nodeAsString(parametersNode),
-        string = `Some(${variableString}, (${parametersString}) { ... })`;
+function stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context) {
+  const variableString = variable.getString(),
+        anonymousProcedureString = anonymousProcedure.getString(),
+        string = `Some(${variableString}, ${anonymousProcedureString}) `;
 
   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/step.js

@@ -3,13 +3,13 @@
 import dom from "../dom";
 
 import { domAssigned } from "../dom";
+import { EMPTY_STRING } from "../constants";
 
 export default domAssigned(class Step {
-  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration) {
+  constructor(string, arrayAssignment, objectAssigment, variablesDeclaration) {
     this.string = string;
     this.arrayAssignment = arrayAssignment;
     this.objectAssigment = objectAssigment;
-    this.conditionalBlocks = conditionalBlocks;
     this.variablesDeclaration = variablesDeclaration;
   }
 
@@ -25,10 +25,6 @@ export default domAssigned(class Step {
     return this.objectAssigment;
   }
 
-  getConditionalBlocks() {
-    return this.conditionalBlocks;
-  }
-
   getVariablesDeclaration() {
     return this.variablesDeclaration;
   }
@@ -40,8 +36,6 @@ export default domAssigned(class Step {
       this.arrayAssignment.evaluate(context);
     } else if (this.objectAssigment !== null) {
       this.objectAssigment.evaluate(context);
-    } else if (this.conditionalBlocks !== null) {
-      this.conditionalBlocks.evaluate(context);
     } else if (this.variablesDeclaration !== null) {
       this.variablesDeclaration.evaluate(context);
     }
@@ -50,15 +44,19 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignments } = dom,
-          node = stepNode,  ///
-          string = context.nodeAsString(node),
+    const { ArrayAssignment, ObjectAssigment, VariableAssignments } = dom,
+          string = stringFromNothing(context),
           arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
           objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
-          conditionalBlocks = ConditionalBlocks.fromStepNode(stepNode, context),
           variablesDeclaration = VariableAssignments.fromStepNode(stepNode, context),
-          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration);
+          step = new Step(string, arrayAssignment, objectAssigment, variablesDeclaration);
 
     return step;
   }
 });
+
+function stringFromNothing(context) {
+  const string = EMPTY_STRING;
+
+  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.asString(context),
+        ifValueString = ifValue.asString(context),
+        elseValueString = elseValue.asString(context),
+        string = `If (${valueString}) ${ifValueString} Else ${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;
+}