occam-verify-cli 0.0.869 → 0.0.870

package/src/verify/metavariableAgainstStatement.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import TermForVariableSubstitution from "../substitution/termForVariable";
+import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+export default function verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead) {
+  let metavariableVerifiedAgainstStatement = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
+
+    if (substitutionMatchesMetavariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const substitutionStatementNode = substitution.getStatementNode();
+
+    if (substitutionNode !== null) {
+      const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+            substitution = termForVariableSubstitution, ///
+            statementNodeA = substitutionStatementNode, ///
+            statementNodeB = statementNode, ///
+            statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+
+      if (statementVerifiedAgainstStatement) {
+        const verifiedAhead = verifyAhead();
+
+        metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+      }
+    } else {
+      const substitutionSubstitution = substitution.getSubstitution();
+
+      if (substitutionSubstitution !== null) {
+        localContextA = localContextB;  ///
+
+        const substitution = substitutionSubstitution,
+              statementNodeA = statementNode, ///
+              statementNodeB = substitutionStatementNode, ///
+              statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+
+        if (statementVerifiedAgainstStatement) {
+          const verifiedAhead = verifyAhead();
+
+          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+        }
+      } else {
+        const statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+        if (statementNodeMatches) {
+          const verifiedAhead = verifyAhead();
+
+          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+        }
+      }
+    }
+  } else {
+    let verifiedAhead;
+
+    const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
+          substitution = statementForMetavariableSubstitution;  ///
+
+    substitutions.push(substitution);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      substitutions.pop();
+    }
+
+    metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+  }
+
+  return metavariableVerifiedAgainstStatement;
+}

package/src/verify/statement.js

@@ -12,9 +12,9 @@ import { nodeQuery } from "../utilities/query";
 const termNodeQuery = nodeQuery("/statement/term!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
       definingNodeQuery = nodeQuery("/statement/defining!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      statementNodeQuery = nodeQuery("/metastatement/statement!"),
       containmentNodeQuery = nodeQuery("/statement/containment!"),
-      metaArgumentNodeQuery = nodeQuery("/statement/metaArgument!"),
+      metastatementNodeQuery = nodeQuery("/statement/metastatement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
@@ -151,11 +151,11 @@ function verifyStatementAboutContainment(statementNode, assignments, derived, lo
     localContext.trace(`Verifying the '${statementString}' statement about containment...`, statementNode);
 
     const termNode = termNodeQuery(statementNode),
-          metaArgumentNode = metaArgumentNodeQuery(statementNode),
-          containmentVerified = verifyContainment(termNode, containmentNode, metaArgumentNode, localContext);
+          metastatementNode = metastatementNodeQuery(statementNode),
+          containmentVerified = verifyContainment(termNode, containmentNode, metastatementNode, localContext);
 
     if (containmentVerified) {
-      statementNode = statementNodeQuery(metaArgumentNode); ///
+      statementNode = statementNodeQuery(metastatementNode); ///
 
       const verifyStatementFunctions = [
         verifyStatementAsEquality,

package/src/verify/statementAgainstMetaType.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
+
+export default function verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead) {
+  let statementVerifiedAgainstMetaType = false;
+
+  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+        content = metaTypeTerminalNode.getContent();
+
+  if (content === STATEMENT_META_TYPE_NAME) {
+    const verifiedAhead = verifyAhead();
+
+    statementVerifiedAgainstMetaType = verifiedAhead; ///
+  }
+
+  return statementVerifiedAgainstMetaType;
+}

package/src/verify/statementAtainstStatement.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import TermForVariableSubstitution from "../substitution/termForVariable";
+import intrinsicLevelNodesVerifier from "../verifier/nodes/intrinsicLevel";
+
+import { push } from "../utilities/array";
+
+export default function verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementVerifiedAgainstStatement = false;
+
+  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
+        transformed = termForVariableSubstitution.isTransformed(substitution);
+
+  let substitutionsA = []; ///
+
+  if (transformed) {
+    const substitutionA = termForVariableSubstitution;  ///
+
+    substitutionsA.push(substitutionA);
+  }
+
+  const nonTerminalNodeA = statementNodeA,  ///
+        nonTerminalNodeB = statementNodeB,  ///
+        nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+  if (nonTerminalNodeVerified) {
+    if (!transformed) {
+      const substitutionB = termForVariableSubstitution,  ///
+            substitutionsB = [
+              substitutionB
+            ];
+
+      substitutionsA = transformSubstitutions(substitutionsA, substitutionsB);
+
+      push(substitutions, substitutionsA);
+    }
+
+    statementVerifiedAgainstStatement = true;
+  }
+
+  return statementVerifiedAgainstStatement;
+}
+
+function transformSubstitutions(substitutionsA, substitutionsB) {
+  substitutionsA = substitutionsA.map((substitutionA) => {
+    const substitution = substitutionA,  ///
+          substitutions = substitutionsB,
+          termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
+
+    substitutionA = termForVariableSubstitution; ///
+
+    return substitutionA;
+  });
+
+  return substitutionsA;
+}

package/src/verify/term.js

@@ -1,9 +1,8 @@
 "use strict";
 
 import Term from "../term";
-import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
-import verifyGivenVariable from "../verify/givenVariable";
 import bracketedConstructor from "../constructor/bracketed";
+import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
@@ -74,27 +73,24 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variables = [],
-          givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, () => {
-            let verifiedAhead;
+    const variable = localContext.findVariableByVariableNode(variableNode);
 
-            const firstVariable = first(variables),
-                  variable = firstVariable, ///
-                  type = variable.getType(),
-                  term = Term.fromTermNodeAndType(termNode, type);
+    if (variable !== null) {
+      let verifiedAhead;
 
-            terms.push(term);
+      const type = variable.getType(),
+            term = Term.fromTermNodeAndType(termNode, type);
 
-            verifiedAhead = verifyAhead();
+      terms.push(term);
 
-            if (!verifiedAhead) {
-              terms.pop();
-            }
+      verifiedAhead = verifyAhead();
 
-            return verifiedAhead;
-          });
+      if (!verifiedAhead) {
+        terms.pop();
+      }
 
-    termVerifiedAsVariable = givenVariableVerified;  ///
+      termVerifiedAsVariable = verifiedAhead;  ///
+    }
 
     if (termVerifiedAsVariable) {
       localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);

package/src/verify/termAgainstTerm.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { areTermNodesEqual } from "../utilities/equivalences";
+
+export default function verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead) {
+  let termVerifiedAgainstTerm = false;
+
+  const leftTermNode = termNodeA, ///
+        rightTermNode = termNodeB, ///
+        equivalences = localContext.getEquivalences(),
+        termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
+
+  if (termNodesEqual) {
+    const verifiedAhead = verifyAhead();
+
+    termVerifiedAgainstTerm = verifiedAhead;  ///
+  }
+
+  return termVerifiedAgainstTerm;
+}

package/src/verify/termAgainstType.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { first } from "../utilities/array";
+
+export default function verifyTermAgainstType(termNode, typeNode, localContext, verifyAhead, verifyTerm) {
+  let termVerifiedAgainstType;
+
+  const terms = [],
+        termVerified = verifyTerm(termNode, terms, localContext, () => {
+          let verifiedAhead = false;
+
+          const firstTerm = first(terms),
+                term = firstTerm, ///
+                termType = term.getType(),
+                type = localContext.findTypeByTypeNode(typeNode),
+                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+          if (termTypeEqualToOrSubTypeOfType) {
+            verifiedAhead = verifyAhead();
+          }
+
+          return verifiedAhead;
+        });
+
+  termVerifiedAgainstType = termVerified; ///
+
+  return termVerifiedAgainstType;
+}

package/src/verify/terms.js

@@ -18,9 +18,7 @@ export default function verifyTerms(termNodes, terms, localContext, verifyAhead)
           let verifiedAhead;
 
           const secondTermVerified = verifyTerm(secondTermNode, terms, localContext, () => {
-            let verifiedAhead;
-
-            verifiedAhead = verifyAhead();
+            const verifiedAhead = verifyAhead();
 
             return verifiedAhead;
           });

package/src/verify/type.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import Type from "../type";
-import verifyGivenType from "../verify/givenType";
 
 import { typeNameFromTypeNode } from "../utilities/name";
 
@@ -52,16 +51,19 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 }
 
 export function verifyStandaloneType(typeNode, localContext, verifyAhead) {
-  let standaloneTypeVerified;
+  let standaloneTypeVerified = false;
 
   const typeString = localContext.nodeAsString(typeNode);
 
   localContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
 
-  const types = [],
-        givenTypeVerified = verifyGivenType(typeNode, types, localContext, verifyAhead);
+  const typePresent = localContext.isTypePresentByTypeNode(typeNode);
 
-  standaloneTypeVerified = givenTypeVerified;  ///
+  if (typePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneTypeVerified = verifiedAhead; ///
+  }
 
   if (standaloneTypeVerified) {
     localContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);

package/src/verify/typeAssertion.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import Variable from "../variable";
+import verifyTerm from "../verify/term";
 import VariableAssignment from "../assignment/variable";
-import verifyTermAndGivenType from "../verify/termAndGivenType";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
-import { verifyTermAsGivenVariable } from "./term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
@@ -21,7 +20,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
 
   const verifyTypeAssertionFunctions = [
     verifyDerivedTypeAssertion,
-    verifyGivenTypeAssertion
+    verifyStatedTypeAssertion
   ];
 
   typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
@@ -48,38 +47,39 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
     localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
 
     const terms = [],
-          types = [],
           termNode = termNodeQuery(typeAssertionNode),
-          typeNode = typeNodeQuery(typeAssertionNode),
-          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, localContext, () => {
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  firstType = first(types),
-                  term = firstTerm, ///
-                  type = firstType, ///
-                  termType = localContext.getTermType(term),
-                  typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
+            const typeNode = typeNodeQuery(typeAssertionNode),
+                  type = localContext.findTypeByTypeNode(typeNode);
 
-            if (typeEqualToOrSuperTypeOfTermType) {
-              const variableNode = variableNodeQuery(termNode);
+            if (type !== null) {
+              const firstTerm = first(terms),
+                    term = firstTerm, ///
+                    termType = localContext.getTermType(term),
+                    typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
 
-              if (variableNode === null) {
-                verifiedAhead = verifyAhead();
-              } else {
-                let variable = localContext.findVariableByVariableNode(variableNode);
+              if (typeEqualToOrSuperTypeOfTermType) {
+                const variableNode = variableNodeQuery(termNode);
 
-                variable = Variable.fromVariableAndType(variable, type);
+                if (variableNode === null) {
+                  verifiedAhead = verifyAhead();
+                } else {
+                  let variable = localContext.findVariableByVariableNode(variableNode);
 
-                const variableAssignment = VariableAssignment.fromVariable(variable),
-                      assignment = variableAssignment;  ///
+                  variable = Variable.fromVariableAndType(variable, type);
 
-                assignments.push(assignment);
+                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                        assignment = variableAssignment;  ///
 
-                verifiedAhead = verifyAhead();
+                  assignments.push(assignment);
 
-                if (!verifiedAhead) {
-                  assignments.pop();
+                  verifiedAhead = verifyAhead();
+
+                  if (!verifiedAhead) {
+                    assignments.pop();
+                  }
                 }
               }
             }
@@ -87,7 +87,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
             return verifiedAhead;
           });
 
-    derivedTypeAssertionVerified = termAndGivenTypeVerified; ///
+    derivedTypeAssertionVerified = termVerified; ///
 
     if (derivedTypeAssertionVerified) {
       localContext.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
@@ -97,47 +97,48 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
   return derivedTypeAssertionVerified;
 }
 
-function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
-  let givenTypeAssertionVerified = false;
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
+  let statedTypeAssertionVerified = false;
 
   if (!derived) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
-    localContext.trace(`Verifying the '${typeAssertionString}' given type assertion...`, typeAssertionNode);
+    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);
 
     const terms = [],
-          types = [],
           termNode = termNodeQuery(typeAssertionNode),
-          typeNode = typeNodeQuery(typeAssertionNode),
-          termAndGivenTypeVerified = verifyTermAndGivenType(termNode, typeNode, terms, types, localContext, () => {
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  firstType = first(types),
-                  term = firstTerm, ///
-                  type = firstType, ///
-                  termType = term.getType(),
-                  typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+            const typeNode = typeNodeQuery(typeAssertionNode),
+                  type = localContext.findTypeByTypeNode(typeNode);
+
+            if (type !== null) {
+              const firstTerm = first(terms),
+                    term = firstTerm, ///
+                    termType = term.getType(),
+                    typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
 
-            if (typeEqualToOrSubTypeOfTermType) {
-              const variableNode = variableNodeQuery(termNode);
+              if (typeEqualToOrSubTypeOfTermType) {
+                const variableNode = variableNodeQuery(termNode);
 
-              if (variableNode === null) {
-                verifiedAhead = verifyAhead();
-              } else {
-                let variable = localContext.findVariableByVariableNode(variableNode);
+                if (variableNode === null) {
+                  verifiedAhead = verifyAhead();
+                } else {
+                  let variable = localContext.findVariableByVariableNode(variableNode);
 
-                variable = Variable.fromVariableAndType(variable, type);
+                  variable = Variable.fromVariableAndType(variable, type);
 
-                const variableAssignment = VariableAssignment.fromVariable(variable),
-                      assignment = variableAssignment;  ///
+                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                        assignment = variableAssignment;  ///
 
-                assignments.push(assignment);
+                  assignments.push(assignment);
 
-                verifiedAhead = verifyAhead();
+                  verifiedAhead = verifyAhead();
 
-                if (!verifiedAhead) {
-                  assignments.pop();
+                  if (!verifiedAhead) {
+                    assignments.pop();
+                  }
                 }
               }
             }
@@ -145,12 +146,12 @@ function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, local
             return verifiedAhead;
           });
 
-    givenTypeAssertionVerified = termAndGivenTypeVerified; ///
+    statedTypeAssertionVerified = termVerified; ///
 
-    if (givenTypeAssertionVerified) {
-      localContext.trace(`...verified the '${typeAssertionString}' given type assertion.`, typeAssertionNode);
+    if (statedTypeAssertionVerified) {
+      localContext.trace(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);
     }
   }
 
-  return givenTypeAssertionVerified;
+  return statedTypeAssertionVerified;
 }

package/src/verify/variable.js

@@ -2,7 +2,6 @@
 
 import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
-import verifyGivenVariable from "../verify/givenVariable";
 
 import { objectType } from "../type";
 
@@ -54,16 +53,19 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
 }
 
 export function verifyStandaloneVariable(variableNode, localContext, verifyAhead) {
-  let standaloneVariableVerified;
+  let standaloneVariableVerified = false;
 
   const variableString = localContext.nodeAsString(variableNode);
 
   localContext.trace(`Verifying the '${variableString}' standalone variable...`, variableNode);
 
-  const variables = [],
-        givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, verifyAhead);
+  const variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
 
-  standaloneVariableVerified = givenVariableVerified; ///
+  if (variablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneVariableVerified = verifiedAhead; ///
+  }
 
   if (standaloneVariableVerified) {
     localContext.debug(`...verified the '${variableString}' standalone variable.`, variableNode);

package/src/verify/variableAgainstTerm.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+
+import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable");
+
+export default function verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead) {
+  let variableVerifiedAgainstTerm = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNode);
+
+    if (substitutionMatchesVariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const termNodeMatches = substitution.matchTermNode(termNode);
+
+    if (termNodeMatches) {
+      const verifiedAhead = verifyAhead();
+
+      variableVerifiedAgainstTerm = verifiedAhead;  ///
+    }
+  } else {
+    const variableA = localContextA.findVariableByVariableNode(variableNode);
+
+    if (variableA !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContextB, () => {
+              let verifiedAhead = false;
+
+              const firstTerm = first(terms),
+                    termB = firstTerm, ///
+                    variableB = variableFromTerm(termB, localContextB);
+
+              if (variableA === variableB) {
+                verifiedAhead = verifyAhead();
+              } else {
+                const term = termB, ///
+                      variable = variableA, ///
+                      termType = term.getType(),
+                      variableType = variable.getType(),
+                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+
+                if (variableTypeEqualToOrSuperTypeOfTermType) {
+                  const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+                        substitution = termForVariableSubstitution;  ///
+
+                  substitutions.push(substitution);
+
+                  verifiedAhead = verifyAhead();
+
+                  if (!verifiedAhead) {
+                    substitutions.pop();
+                  }
+                }
+              }
+
+              return verifiedAhead;
+            });
+
+      variableVerifiedAgainstTerm = termVerified;  ///
+    }
+  }
+
+  return variableVerifiedAgainstTerm;
+}
+
+function variableFromTerm(term, localContext) {
+  let variable = null;
+
+  const termNode = term.getNode(),
+        variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    variable = localContext.findVariableByVariableNode(variableNode);
+  }
+
+  return variable;
+}