occam-furtle 2.0.331 → 2.0.334

package/src/utilities/element.js

@@ -5,13 +5,15 @@ import { Query } from "occam-query";
 import elements from "../elements";
 
 import { BOOLEAN_TYPE } from "../types";
-import { variableStringFromName,
+import { ternaryStringFromTerm,
+         variableStringFromName,
+         termStringFromPrimitiveAndProperties,
          procedureDeclarationStringFromProcedure,
          returnBlockStringFromReturnStatementNode,
          expressionStringFromPrimitiveAndProperties,
+         variableAssignmentStringFromTypeAndVariable,
          someStringFromVariableAndAnonymousProcedure,
          everyStringFromVariableAndAnonymousProcedure,
-         variableAssignmentStringFromVariable,
          procedureStringFromTypeLabelParametersAndReturnBlock,
          variableAssignmentStringFromVariableAssignmentsArray,
          anonymousProcedureStringFromTypeParametersAndReturnBlock,
@@ -42,11 +44,22 @@ export function someFromSomeNode(someNode, context) {
 
 export function termFromTermNode(termNode, context) {
   const { Term } = elements,
-        node = termNode,  ///
-        string = context.nodeAsString(node),
         variable = variableFromTermNode(termNode, context),
         primitive = primitiveFromTermNode(termNode, context),
-        term = new Term(string, variable, primitive);
+        negatedTerm = negatedTermFromTermNode(termNode, context),
+        logicalTerm = logicalTermFromTermNode(termNode, context),
+        bracketedTerm = bracketedTermFromTermNode(termNode, context),
+        comparisonTerm = comparisonTermFromTermNode(termNode, context),
+        properties = [
+          variable,
+          negatedTerm,
+          logicalTerm,
+          bracketedTerm,
+          comparisonTerm
+        ],
+        termString = termStringFromPrimitiveAndProperties(primitive, properties, context),
+        string = termString,  ///
+        term = new Term(string, variable, primitive, negatedTerm, logicalTerm, bracketedTerm, comparisonTerm);
 
   return term;
 }
@@ -107,12 +120,12 @@ export function reduceFromReduceNode(reduceNode, context) {
 
 export function ternaryFromTernaryNode(ternaryNode, context) {
   const { Ternary } = elements,
-        node = ternaryNode, ///
-        string = context.nodeAsString(node),
-        expression = expressionFromTernaryNode(ternaryNode, context),
+        term = termFromTernaryNode(ternaryNode, context),
         ifExpression = ifExpressionFromTernaryNode(ternaryNode, context),
         elseExpression = elseExpressionFromTernaryNode(ternaryNode, context),
-        ternary = new Ternary(string, expression, ifExpression, elseExpression);
+        ternaryString = ternaryStringFromTerm(term),
+        string = ternaryString, ///
+        ternary = new Ternary(string, term, ifExpression, elseExpression);
 
   return ternary;
 }
@@ -227,12 +240,12 @@ export function expressionFromExpressionNode(expressionNode, context) {
           variable,
           nodeQuery,
           nodesQuery,
-          comparisonExpression,
           returnBlock,
           procedureCall,
           negatedExpression,
           logicalExpression,
-          bracketedExpression
+          bracketedExpression,
+          comparisonExpression
         ],
         expressionString = expressionStringFromPrimitiveAndProperties(primitive, properties, context),
         string = expressionString,  ///
@@ -339,6 +352,19 @@ export function negatedExpressionFromNegatedExpressionNode(negatedExpressionNode
   return negatedExpression;
 }
 
+export function logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context) {
+  const { LogicalExpression } = elements,
+        node = logicalExpressionNode, ///
+        string = context.nodeAsString(node),
+        type = typeFromLogicalExpressionNode(logicalExpressionNode, context),
+        disjunction = disjunctionFromLogicalExpressionNode(logicalExpressionNode, context),
+        leftExpression = leftExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
+        rightExpression = rightExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
+        logicalExpression = new LogicalExpression(string, type, disjunction, leftExpression, rightExpression);
+
+  return logicalExpression;
+}
+
 export function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
   const { AnonymousProcedure } = elements,
         type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
@@ -351,16 +377,6 @@ export function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureN
   return anonymousProcedure;
 }
 
-export function bracketedExpressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
-  const { BracketedExpression } = elements,
-        node = bracketedExpressionNode, ///
-        string = context.nodeAsString(node),  ///
-        expression = expressionFromBracketedExpressionNode(bracketedExpressionNode, context),
-        bracketedExpression = new BracketedExpression(string, expression);
-
-  return bracketedExpression;
-}
-
 export function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
   const { VariableAssignments } = elements,
         variableAssignmentsArray = variableAssignmentsArrayFromVariableAssignmentsNode(variableAssignmentsNode, context),
@@ -372,14 +388,14 @@ export function variableAssignmentsFromVariableAssignmentsNode(variableAssignmen
   return variableAssignments;
 }
 
-export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const { ProcedureDeclaration } = elements,
-        procedure = procedureFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        procedureDeclarationString = procedureDeclarationStringFromProcedure(procedure),
-        string = procedureDeclarationString,  ///
-        procedureDeclaration = new ProcedureDeclaration(string, procedure);
+export function bracketedExpressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
+  const { BracketedExpression } = elements,
+        node = bracketedExpressionNode, ///
+        string = context.nodeAsString(node),  ///
+        expression = expressionFromBracketedExpressionNode(bracketedExpressionNode, context),
+        bracketedExpression = new BracketedExpression(string, expression);
 
-  return procedureDeclaration;
+  return bracketedExpression;
 }
 
 export function comparisonExpressionFromComparisonExpressionNode(comparisonExpressionNode, context) {
@@ -387,19 +403,36 @@ export function comparisonExpressionFromComparisonExpressionNode(comparisonExpre
         node = comparisonExpressionNode,  ///
         string = context.nodeAsString(node),
         negated = negatedFromComparisonExpressionNode(comparisonExpressionNode, context),
-        leftExpression = leftExpressionFromCompzrisonNode(comparisonExpressionNode, context),
-        rightExpression = rightExpressionFromCompzrisonNode(comparisonExpressionNode, context),
+        leftExpression = leftExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context),
+        rightExpression = rightExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context),
         comparisonExpression = new ComparisonExpression(string, negated, leftExpression, rightExpression);
 
   return comparisonExpression;
 }
 
+export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { ProcedureDeclaration } = elements,
+        procedure = procedureFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        procedureDeclarationString = procedureDeclarationStringFromProcedure(procedure),
+        string = procedureDeclarationString,  ///
+        procedureDeclaration = new ProcedureDeclaration(string, procedure);
+
+  return procedureDeclaration;
+}
+
 export function nameFromLabelNode(labelNode, context) {
   const name = labelNode.getName();
 
   return name;
 }
 
+export function termFromTernaryNode(ternaryNode, context) {
+  const termNode = ternaryNode.getTermNode(),
+        term = termFromTermNode(termNode, context);
+
+  return term;
+}
+
 export function variableFromSomeNode(someNode, context) {
   const variableNode = someNode.getVariableNode(), ///
         variable = variableFromVariableNode(variableNode, context);
@@ -533,6 +566,43 @@ export function everyFromExpressionNode(expressionNode, context) {
   return every;
 }
 
+export function negatedTermFromTermNode(termNode, context) {
+  let negatedTerm = null;
+
+  const negatedTermNode = termNode.getNegatedTermNode();
+
+  if (negatedTermNode !== null) {
+    negatedTerm = negatedTermFromNegatedTermNode(negatedTermNode, context);
+  }
+
+  return negatedTerm;
+}
+
+export function logicalTermFromTermNode(termNode, context) {
+  let logicalTerm = null;
+
+  const logicalTermNode = termNode.getLogicalTermNode();
+
+  if (logicalTermNode !== null) {
+    logicalTerm = logicalTermFromLogicalTermNode(logicalTermNode, context);
+  }
+
+  return logicalTerm;
+}
+
+export function typeFromLogicalTermNode(logicalTermNode, context) {
+  const type = BOOLEAN_TYPE;
+
+  return type;
+}
+
+export function termFromNegatedTermNode(negatedTermNode, context) {
+  const termNode = negatedTermNode.getTermNode(),
+    term = termFromTermNode(termNode, context);
+
+  return term;
+}
+
 export function booleanFromPrimitiveNode(primitiveNode, context) {
   const boolean = primitiveNode.getBoolean();
 
@@ -569,13 +639,6 @@ export function stepsFromReturnBlockNode(returnBlockNode, context) {
   return steps;
 }
 
-export function expressionFromTernaryNode(ternaryNode, context) {
-  const expressionNode = ternaryNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
-
-  return expression;
-}
-
 export function variableFromNodeQueryNode(nodeQueryNode, context) {
   const variableNode = nodeQueryNode.getVariableNode(),
         variable = variableFromVariableNode(variableNode, context);
@@ -595,6 +658,37 @@ export function ternaryFromExpressionNode(expressionNode, context) {
   return ternary;
 }
 
+export function bracketedTermFromTermNode(termNode, context) {
+  let bracketedTerm = null;
+
+  const bracketedTermNode = termNode.getBracketedTermNode();
+
+  if (bracketedTermNode !== null) {
+    bracketedTerm = bracketedTermFromBracketedTermNode(bracketedTermNode, context);
+  }
+
+  return bracketedTerm;
+}
+
+export function termFromBracketedTermNode(bracketedTermNode, context) {
+  const termNode = bracketedTermNode.getTermNode(),
+    term = termFromTermNode(termNode, context);
+
+  return term;
+}
+
+export function comparisonTermFromTermNode(termNOde, context) {
+  let comparisonTerm = null;
+
+  const comparisonTermNode = termNOde.getComparisonTermNode();
+
+  if (comparisonTermNode !== null) {
+    comparisonTerm = comparisonTermFromComparisonTermNode(comparisonTermNode, context);
+  }
+
+  return comparisonTerm;
+}
+
 export function expressionFromVariableNode(variableNode, context) {
   const expression = null;
 
@@ -639,6 +733,13 @@ export function nameFromNamedParameterNode(namedParameterNode, context) {
   return name;
 }
 
+export function leftTermFromLogicalTermNode(logicalTermNode, context) {
+  const leftTermNode = logicalTermNode.getLeftTermNode(),
+    leftTerm = termFromTermNode(leftTermNode, context);
+
+  return leftTerm;
+}
+
 export function arrayAssignmentFromStepNode(stepNode, context) {
   let arrayAssignment = null;
 
@@ -719,6 +820,19 @@ export function nodesQueryFromExpressionNode(expressionNode, context) {
   return nodesQuery;
 }
 
+export function rightTermFromLogicalTermNode(logicalTermNode, context) {
+  const rightTermNode = logicalTermNode.getRightTermNode(),
+       rightTerm = termFromTermNode(rightTermNode, context);
+
+  return rightTerm;
+}
+
+export function negatedFromComparisonTermNode(comparisonTermNode, context) {
+  const negated = comparisonTermNode.isNegated();
+
+  return negated;
+}
+
 export function elseExpressionFromTernaryNode(ternaryNode, context) {
   const elseExpressionNode = ternaryNode.getElseExpressionNode(),
         elseExpression = expressionFromExpressionNode(elseExpressionNode, context);
@@ -744,7 +858,7 @@ export function typeFromNegatedExpressionNode(negatedExpressionNode, context) {
   return type;
 }
 
-export function typeFromLogcialExpressionNode(logicalExpressionNode, context) {
+export function typeFromLogicalExpressionNode(logicalExpressionNode, context) {
   const type = BOOLEAN_TYPE;
 
   return type;
@@ -776,6 +890,44 @@ export function stringLiteralFromPrimitiveNode(primitiveNode, context) {
   return stringLiteral;
 }
 
+export function leftTermFromCompzrisonTermNode(comparisonTermNode, context) {
+  const leftTermNode = comparisonTermNode.getLeftTermNode(),
+        leftTerm = termFromTermNode(leftTermNode, context);
+
+  return leftTerm;
+}
+
+export function disjunctionFromLogicalTermNode(logicalTermNode, context) {
+  const disjunction = logicalTermNode.isDisjunction();
+
+  return disjunction;
+}
+
+export function negatedTermFromNegatedTermNode(negatedTermNode, context) {
+  const { NegatedTerm } = elements,
+        node = negatedTermNode, ///
+        string = context.nodeAsString(node),
+        termNode = negatedTermNode.getTermNode(),
+        type = typeFromNegatedTermNode(termNode, context),
+        term = termFromNegatedTermNode(negatedTermNode, context),
+        negatedTerm = new NegatedTerm(string, type, term);
+
+  return negatedTerm;
+}
+
+export function logicalTermFromLogicalTermNode(logicalTermNode, context) {
+  const { LogicalTerm } = elements,
+        node = logicalTermNode, ///
+        string = context.nodeAsString(node),
+        type = typeFromLogicalTermNode(logicalTermNode, context),
+        disjunction = disjunctionFromLogicalTermNode(logicalTermNode, context),
+        leftTerm = leftTermFromLogicalTermNode(logicalTermNode, context),
+        rightTerm = rightTermFromLogicalTermNode(logicalTermNode, context),
+        logicalTerm = new LogicalTerm(string, type, disjunction, leftTerm, rightTerm);
+
+  return logicalTerm;
+}
+
 export function variableFromTypeAndVariableNode(type, variableNode, context) {
   const { Variable } = elements,
         name = nameFromVariableNode(variableNode),
@@ -832,6 +984,13 @@ export function variableFromArrayAssignmentNode(arrayAssignmentNode, context) {
   return variable;
 }
 
+export function rightTermFromCompzrisonTermNode(comparisonTermNode, context) {
+  const rightTermNode = comparisonTermNode.getLeftTermNode(),
+        rightTerm = termFromTermNode(rightTermNode, context);
+
+  return rightTerm;
+}
+
 export function anonymousProcedureFromReduceNode(reduceNode, context) {
   const anonymousProcedureNode = reduceNode.getAnonymousProcedureNode(),
         anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
@@ -839,13 +998,6 @@ export function anonymousProcedureFromReduceNode(reduceNode, context) {
   return anonymousProcedure;
 }
 
-export function leftExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
-  const leftExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
-        leftExpression = expressionFromExpressionNode(leftExpressionNode, context);
-
-  return leftExpression;
-}
-
 export function variableFromObjectAssignmentNode(objectAssignmentNode, context) {
   const variableNode = objectAssignmentNode.getVariableNode(),
         variable = variableFromVariableNode(variableNode, context);
@@ -865,13 +1017,6 @@ export function expressionFromTypeAndVariableNode(type, variableNode, context) {
   return expression;
 }
 
-export function rightExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
-  const rightExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
-        rightExpression = expressionFromExpressionNode(rightExpressionNode, context);
-
-  return rightExpression;
-}
-
 export function parametersFromArrayAssignmentNode(arrayAssignmentNode, context) {
   const parametersNode = arrayAssignmentNode.getParametersNode(),
         parameters = parametersFromParametersNode(parametersNode, context);
@@ -893,6 +1038,16 @@ export function returnStatementFromReturnBlockNode(returnBlockNode, context) {
   return returnStatement;
 }
 
+export function bracketedTermFromBracketedTermNode(bracketedTermNode, context) {
+  const { BracketedTerm } = elements,
+        node = bracketedTermNode, ///
+        string = context.nodeAsString(node),  ///
+        term = termFromBracketedTermNode(bracketedTermNode, context),
+        bracketedTerm = new BracketedTerm(string, term);
+
+  return bracketedTerm;
+}
+
 export function negatedExpressionFromExpressionNode(expressionNode, context) {
   let negatedExpression = null;
 
@@ -905,16 +1060,11 @@ export function negatedExpressionFromExpressionNode(expressionNode, context) {
   return negatedExpression;
 }
 
-export function logicalExpressionFromExpressionNode(expressionNode, context) {
-  let logicalExpression = null;
-
-  const logicalExpressionNode = expressionNode.getLogicalExpressionNode();
-
-  if (logicalExpressionNode !== null) {
-    logicalExpression = logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context);
-  }
+export function expressionFromNegatedExpressionNode(negatedExpressionNode, context) {
+  const expressionNode = negatedExpressionNode.getExpressionNode(),
+        expression = expressionFromExpressionNode(expressionNode, context);
 
-  return logicalExpression;
+  return expression;
 }
 
 export function negatedFromComparisonExpressionNode(comparisonExpressionNode, context) {
@@ -923,11 +1073,16 @@ export function negatedFromComparisonExpressionNode(comparisonExpressionNode, co
   return negated;
 }
 
-export function expressionFromNegatedExpressionNode(negatedExpressionNode, context) {
-  const expressionNode = negatedExpressionNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
+export function logicalExpressionFromExpressionNode(expressionNode, context) {
+  let logicalExpression = null;
 
-  return expression;
+  const logicalExpressionNode = expressionNode.getLogicalExpressionNode();
+
+  if (logicalExpressionNode !== null) {
+    logicalExpression = logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context);
+  }
+
+  return logicalExpression;
 }
 
 export function expressionFromVariableAssignmentNode(variableAssigmentNode, context) {
@@ -950,6 +1105,18 @@ export function parametersFromAnonymousProcedureNode(anonymousProcedureNode, con
   return parameters;
 }
 
+export function comparisonTermFromComparisonTermNode(comparisonTermNode, context) {
+  const { ComparisonTerm } = elements,
+        node = comparisonTermNode,  ///
+        string = context.nodeAsString(node),
+        negated = negatedFromComparisonTermNode(comparisonTermNode, context),
+        leftTerm = leftTermFromCompzrisonTermNode(comparisonTermNode, context),
+        rightTerm = rightTermFromCompzrisonTermNode(comparisonTermNode, context),
+        comparisonTerm = new ComparisonTerm(string, negated, leftTerm, rightTerm);
+
+  return comparisonTerm;
+}
+
 export function returnBlockFromAnonymousProcedureNode(anonymousProcedureNode, context) {
   const returnBlockNode = anonymousProcedureNode.getReturnBlockNode(),
         returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
@@ -957,6 +1124,19 @@ export function returnBlockFromAnonymousProcedureNode(anonymousProcedureNode, co
   return returnBlock;
 }
 
+export function procedureFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { Procedure } = elements,
+        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        label = labelFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        parameters = parametersFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        returnBlock = returnBlockFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        procedureString = procedureStringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
+        string = procedureString, ///
+        procedure = new Procedure(string, type, label, parameters, returnBlock);
+
+  return procedure;
+}
+
 export function bracketedExpressionFromExpressionNode(expressionNode, context) {
   let bracketedExpression = null;
 
@@ -971,24 +1151,11 @@ export function bracketedExpressionFromExpressionNode(expressionNode, context) {
 
 export function expressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
   const expressionNode = bracketedExpressionNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
+    expression = expressionFromExpressionNode(expressionNode, context);
 
   return expression;
 }
 
-export function procedureFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const { Procedure } = elements,
-        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        label = labelFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        parameters = parametersFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        returnBlock = returnBlockFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        procedureString = procedureStringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
-        string = procedureString, ///
-        procedure = new Procedure(string, type, label, parameters, returnBlock);
-
-  return procedure;
-}
-
 export function comparisonExpressionFromExpressionNode(expressionNOde, context) {
   let comparisonExpression = null;
 
@@ -1042,24 +1209,25 @@ export function variableFromTypeAndVariableAssignmentNode(type, variableAssignme
   return variable;
 }
 
-export function logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context) {
-  const { LogicalExpression } = elements,
-        node = logicalExpressionNode, ///
-        string = context.nodeAsString(node),
-        type = typeFromLogcialExpressionNode(logicalExpressionNode, context),
-        disjunction = disjunctionFromLogicalExpressionNode(logicalExpressionNode, context),
-        leftExpression = leftExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
-        rightExpression = rightExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
-        logicalExpression = new LogicalExpression(string, type, disjunction, leftExpression, rightExpression);
+export function leftExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context) {
+  const leftExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
+        leftExpression = expressionFromExpressionNode(leftExpressionNode, context);
 
-  return logicalExpression;
+  return leftExpression;
+}
+
+export function rightExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context) {
+  const rightExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
+        rightExpression = expressionFromExpressionNode(rightExpressionNode, context);
+
+  return rightExpression;
 }
 
 export function variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
   const { VariableAssignment } = elements,
         variable = variableFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context),
         expression = expressionFromVariableAssignmentNode(variableAssignmentNode, context),
-        variableAssignmentString = variableAssignmentStringFromVariable(expression, variable, context),
+        variableAssignmentString = variableAssignmentStringFromTypeAndVariable(type, variable, context),
         string = variableAssignmentString,  ///
         assignment = new VariableAssignment(string, variable, expression);
 

package/src/utilities/string.js

@@ -5,6 +5,13 @@ import nullNode from "../nullNode";
 import { NULL } from "../constants";
 import { stringFromStringLiteral } from "./stringLiteral";
 
+export function ternaryStringFromTerm(term) {
+  const termString = term.getString(),
+        ternaryString = `if (${termString}) { ... } else { ... }`;
+
+  return ternaryString;
+}
+
 export function variableStringFromName(name) {
   const variableString = name;  ///
 
@@ -53,9 +60,30 @@ export function primtiveStringFromStringLiteral(stringLiteral) {
   return primtiveString;
 }
 
-export function variableAssignmentStringFromVariable(expression, variable) {
-  const type = variable.getType(),
-        variableString = variable.getString(),
+export function termStringFromPrimitiveAndProperties(primitive, properties) {
+  let termString;
+
+  if (false) {
+    ///
+  } else if (primitive !== null) {
+    const primitiveString = primitive.toString();
+
+    termString = primitiveString; ///
+  } else {
+    properties.forEach((property) => {
+      if (property !== null) {
+        const propertyString = property.getString();
+
+        termString = propertyString;  ///
+      }
+    });
+  }
+
+  return termString;
+}
+
+export function variableAssignmentStringFromTypeAndVariable(type, variable) {
+  const variableString = variable.getString(),
         variableAssignmentString = `${type} ${variableString} = ... ;`;
 
   return variableAssignmentString;