occam-verify-cli 1.0.220 → 1.0.224

package/src/unifier/metaLevel.js

@@ -14,13 +14,13 @@ const termNodeQuery = nodeQuery("/term"),
 
 class MetaLevelUnifier extends Unifier {
   unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
-    let unifiedAtMetaLevel;
+    let unifiesAtMetaLevel;
 
-    const nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+    const nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
+    unifiesAtMetaLevel = nonTerminalNodeUnifies; ///
 
-    return unifiedAtMetaLevel;
+    return unifiesAtMetaLevel;
   }
 
   static maps = [
@@ -28,7 +28,7 @@ class MetaLevelUnifier extends Unifier {
       generalNodeQuery: statementNodeQuery,
       specificNodeQuery: statementNodeQuery,
       unify: (generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext) => {
-        let statementUnified;
+        let statementUnifies;
 
         const statementNode = generalStatementNode, ///
               singularMetavariableNode = statementNode.getSingularMetavariableNode();
@@ -55,21 +55,21 @@ class MetaLevelUnifier extends Unifier {
 
           const statement = Statement.fromStatementNode(statementNode, context);
 
-          statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
+          statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
         } else {
-          const childNodesUnified = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
+          const childNodesUnify = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
 
-          statementUnified = childNodesUnified; ///
+          statementUnifies = childNodesUnify; ///
         }
 
-        return statementUnified;
+        return statementUnifies;
       }
     },
     {
       generalNodeQuery: declarationMetavariableNodeQuery,
       specificNodeQuery: declarationMetavariableNodeQuery,
       unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
-        let referenceUnified;
+        let referenceUnifies;
 
         const { Reference, Metavariable } = dom;
 
@@ -88,16 +88,16 @@ class MetaLevelUnifier extends Unifier {
 
         const reference = Reference.fromMetavariableNode(metavariableNode, context);
 
-        referenceUnified = metavariable.unifyReference(reference, substitutions, generalContext, specificContext);
+        referenceUnifies = metavariable.unifyReference(reference, substitutions, generalContext, specificContext);
 
-        return referenceUnified;
+        return referenceUnifies;
       }
     },
     {
       generalNodeQuery: frameMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
       unify: (generalFrameMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
-        let frameUnified;
+        let frameUnifies;
 
         const { Frame, Metavariable } = dom,
               frameNode = specificFrameNode, ///
@@ -113,16 +113,16 @@ class MetaLevelUnifier extends Unifier {
 
         const frame = Frame.fromFrameNode(frameNode, context);
 
-        frameUnified = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
+        frameUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
 
-        return frameUnified;
+        return frameUnifies;
       }
     },
     {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnified;
+        let termUnifies;
 
         const { Term, Variable } = dom,
               termNode = specificTermNode, ///
@@ -138,9 +138,9 @@ class MetaLevelUnifier extends Unifier {
 
         const term = Term.fromTermNode(termNode, context);
 
-        termUnified = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 
-        return termUnified;
+        return termUnifies;
       }
     }
   ];
@@ -157,8 +157,7 @@ function unifyChildNodes(generalStatementNode, specificStatementNode, substituti
         specificNonTerminalNodeChildNodes = specificNonTerminalNode.getChildNodes(),
         generalChildNodes = generalNonTerminalNodeChildNodes, ///
         specificChildNodes = specificNonTerminalNodeChildNodes, ///
-        childNodesVerified = metaLevelUnifier.unifyChildNodes(generalChildNodes, specificChildNodes, substitutions, generalContext, specificContext),
-        childNodesUnified = childNodesVerified; ///
+        childNodesUnify = metaLevelUnifier.unifyChildNodes(generalChildNodes, specificChildNodes, substitutions, generalContext, specificContext);
 
-  return childNodesUnified;
+  return childNodesUnify;
 }

package/src/unifier/metavariable.js

@@ -10,15 +10,15 @@ const typeNodeQuery = nodeQuery("/type"),
 
 class MetavariableUnifier extends Unifier {
   unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) {
-    let metavariableUnified;
+    let metavariableUnifies;
 
     const generalNonTerminalNode = generalMetavariableNode, ///
           specificNonTerminalNode = specificMetavariableNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, generalContext, specificContext);
+          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, generalContext, specificContext);
 
-    metavariableUnified = nonTerminalNodeUnified; ///
+    metavariableUnifies = nonTerminalNodeUnifies; ///
 
-    return metavariableUnified;
+    return metavariableUnifies;
   }
 
   static maps = [
@@ -26,7 +26,7 @@ class MetavariableUnifier extends Unifier {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
-        let termUnified;
+        let termUnifies;
 
         const { Term } = dom,
               typeNode = generalTypeNode, ///
@@ -35,11 +35,11 @@ class MetavariableUnifier extends Unifier {
               type = generalContext.findTypeByTypeName(typeName),
               context = specificContext, ///
               term = Term.fromTermNode(termNode, context),
-              termVerifiedGivenType = term.verifyGivenType(type, generalContext, specificContext);
+              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
 
-        termUnified = termVerifiedGivenType;  ///
+        termUnifies = termVerifiesGivenType;  ///
 
-        return termUnified;
+        return termUnifies;
       }
     }
   ];

package/src/unifier/statementWithCombinator.js

@@ -13,15 +13,15 @@ const termNodeQuery = nodeQuery("/term"),
 
 class StatementWithCombinatorUnifier extends Unifier {
   unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext) {
-    let statementUnifiedWithCombinator;
+    let statementUnifiesWithCombinator;
 
     const generalNonTerminalNode = combinatorStatementNode, ///
           specificNonTerminalNode = statementNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, assignments, stated, generalContext, specificContext);
+          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, assignments, stated, generalContext, specificContext);
 
-    statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
+    statementUnifiesWithCombinator = nonTerminalNodeUnifies; ///
 
-    return statementUnifiedWithCombinator;
+    return statementUnifiesWithCombinator;
   };
 
   static maps = [
@@ -29,7 +29,7 @@ class StatementWithCombinatorUnifier extends Unifier {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: statementNodeQuery,
       unify: (generalMetaTypeNode, specificStatementNode, assignments, stated, generalContext, specificContext) => {
-        let unified;
+        let unifies;
 
         const { Statement, MetaType } = dom,
               metaTypeNode = generalMetaTypeNode, ///
@@ -44,18 +44,18 @@ class StatementWithCombinatorUnifier extends Unifier {
         context = specificContext;  ///
 
         const statement = Statement.fromStatementNode(statementNode, context),
-              statementVerifiedGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
+              statementVerifiesGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
 
-        unified = statementVerifiedGivenType;
+        unifies = statementVerifiesGivenType;
 
-        return unified;
+        return unifies;
       }
     },
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: frameNodeQuery,
       unify: (generalMetaTypeNode, specificFrameNode, assignments, stated, generalContext, specificContext) => {
-        let unified;
+        let unifies;
 
         const { Frame, MetaType } = dom,
               metaTypeNode = generalMetaTypeNode, ///
@@ -70,18 +70,18 @@ class StatementWithCombinatorUnifier extends Unifier {
         context = specificContext;  ///
 
         const frame = Frame.fromFrameNode(frameNode, context),
-              frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
+              frameVerifiesGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
 
-        unified = frameVerifiedGivenType;
+        unifies = frameVerifiesGivenType;
 
-        return unified;
+        return unifies;
       }
     },
     {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTypeNode, specificTermNode, assignments, stated, generalContext, specificContext) => {
-        let unified = false;
+        let unifies = false;
 
         const { Term } = dom,
               typeNode = generalTypeNode, ///
@@ -97,13 +97,13 @@ class StatementWithCombinatorUnifier extends Unifier {
         context = specificContext;  ///
 
         const term = Term.fromTermNode(termNode, context),
-              termVerifiedGivenType = term.verifyGivenType(type, generalContext, specificContext);
+              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
 
-        if (termVerifiedGivenType) {
-          unified = true;
+        if (termVerifiesGivenType) {
+          unifies = true;
         }
 
-        return unified;
+        return unifies;
       }
     }
   ];

package/src/unifier/termWithConstructor.js

@@ -10,15 +10,15 @@ const termNodeQuery = nodeQuery("/term"),
 
 class TermWithConstructorUnifier extends Unifier {
   unify(constructorTermNode, termNode, context) {
-    let termUnifiedWithConstructor;
+    let termUnifiesWithConstructor;
 
     const generalNonTerminalNode = constructorTermNode, ///
           specificNonTerminalNode = termNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
+          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
 
-    termUnifiedWithConstructor = nonTerminalNodeUnified; ///
+    termUnifiesWithConstructor = nonTerminalNodeUnifies; ///
 
-    return termUnifiedWithConstructor;
+    return termUnifiesWithConstructor;
   };
 
   static maps = [
@@ -26,7 +26,7 @@ class TermWithConstructorUnifier extends Unifier {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTypeNode, specificTermNode, context) => {
-        let unified = false;
+        let unifies = false;
 
         const { Term } = dom,
               typeNode = generalTypeNode, ///
@@ -38,14 +38,14 @@ class TermWithConstructorUnifier extends Unifier {
                 term = Term.fromTermNode(termNode, context),
                 generalContext = context, ///
                 specificContext = context,  ///
-                termVerifiedGivenType = term.verifyGivenType(type, generalContext, specificContext);
+                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
 
-          if (termVerifiedGivenType) {
-            unified = true;
+          if (termVerifiesGivenType) {
+            unifies = true;
           }
         }
 
-        return unified;
+        return unifies;
       }
     }
   ];

package/src/unifier.js

@@ -8,17 +8,17 @@ const nonTerminalNodeQuery = nodeQuery("/*");
 
 export default class Unifier {
   unify(generalNode, specificNode, ...remainingArguments) {
-    let unified;
+    let unifies;
 
-    const nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments);
+    const nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments);
 
-    unified = nodeUnified;  ///
+    unifies = nodeUnifies;  ///
 
-    return unified;
+    return unifies;
   }
 
   unifyNode(generalNode, specificNode, ...remainingArguments) {
-    let nodeUnified = false;
+    let nodeUnifies = false;
 
     const generalNodeTerminalNode = generalNode.isTerminalNode(),
           specificNodeTerminalNode = specificNode.isTerminalNode(),
@@ -30,22 +30,22 @@ export default class Unifier {
     } else if (generalNodeTerminalNode && specificNodeTerminalNode) {
       const generalTerminalNode = generalNode,  ///
             specificTerminalNode = specificNode,  ///
-            terminalNodeUnified = this.unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments);
+            terminalNodeUnifies = this.unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments);
 
-      nodeUnified = terminalNodeUnified;  ///
+      nodeUnifies = terminalNodeUnifies;  ///
     } else if (generalNodeNonTerminalNode && specificNodeNonTerminalNode) {
       const generalNonTerminalNode = generalNode,  ///
             specificNonTerminalNode = specificNode, ///
-            nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments);
+            nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments);
 
-      nodeUnified = nonTerminalNodeUnified; ///
+      nodeUnifies = nonTerminalNodeUnifies; ///
     }
 
-    return nodeUnified;
+    return nodeUnifies;
   }
 
   unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let childNodesUnified = false;
+    let childNodesUnify = false;
 
     const generalChildNodesLength = generalChildNodes.length,
           specificChildNodesLength = specificChildNodes.length;
@@ -60,17 +60,17 @@ export default class Unifier {
 
         if (lastRemainingArgumentFunction) {
           const index = 0,
-                childNodesUnifiedAhead = this.unifyChildNodesAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
+                childNodesUnifyAhead = this.unifyChildNodesAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
 
-          childNodesUnified = childNodesUnifiedAhead; ///
+          childNodesUnify = childNodesUnifyAhead; ///
         } else {
-          childNodesUnified = generalChildNodes.every((generalChildNode, index) => {
+          childNodesUnify = generalChildNodes.every((generalChildNode, index) => {
             const specificChildNode = specificChildNodes[index],
                   specificNode = specificChildNode, ///
                   generalNode = generalChildNode, ///
-                  nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments);
+                  nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments);
 
-            if (nodeUnified) {
+            if (nodeUnifies) {
               return true;
             }
           });
@@ -78,30 +78,30 @@ export default class Unifier {
       }
     }
 
-    return childNodesUnified;
+    return childNodesUnify;
   }
 
   unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments) { ///
-    let terminalNodeUnified;
+    let terminalNodeUnifies;
 
     const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
     if (lastRemainingArgumentFunction) {
       const unifyAhead = remainingArguments.pop(),
-            unifiedAhead = unifyAhead();
+            unifiesAhead = unifyAhead();
 
-      terminalNodeUnified = unifiedAhead;  ///
+      terminalNodeUnifies = unifiesAhead;  ///
 
-      remainingArguments.push(unifiedAhead);
+      remainingArguments.push(unifiesAhead);
     } else {
-      terminalNodeUnified = true;
+      terminalNodeUnifies = true;
     }
 
-    return terminalNodeUnified;
+    return terminalNodeUnifies;
   }
 
   unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeUnified;
+    let nonTerminalNodeUnifies;
 
     let { maps } = this.constructor;
 
@@ -111,7 +111,7 @@ export default class Unifier {
         generalNodeQuery: nonTerminalNodeQuery,
         specificNodeQuery: nonTerminalNodeQuery,
         unify: (generalNode, specificNode, ...remainingArguments) => {
-          let nonTerminalNodeUnified;
+          let nonTerminalNodeUnifies;
 
           const generalNonTerminalNodeRuleName = generalNonTerminalNode.getRuleName(), ///
                 specificNonTerminalNodeRuleName = specificNonTerminalNode.getRuleName(); ///
@@ -121,17 +121,17 @@ export default class Unifier {
                   specificNonTerminalNodeChildNode = specificNonTerminalNode.getChildNodes(),
                   generalChildNodes = generalNonTerminalNodeChildNodes, ///
                   specificChildNodes = specificNonTerminalNodeChildNode, ///
-                  childNodesUnified = this.unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments);
+                  childNodesUnify = this.unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments);
 
-            nonTerminalNodeUnified = childNodesUnified; ///
+            nonTerminalNodeUnifies = childNodesUnify; ///
           }
 
-          return nonTerminalNodeUnified;
+          return nonTerminalNodeUnifies;
         }
       }
     ]
 
-    let nodeUnified = false;
+    let nodeUnifies = false;
 
     maps.some((map) => {
       const { generalNodeQuery, specificNodeQuery, unify } = map;
@@ -140,44 +140,44 @@ export default class Unifier {
             specificNode = specificNodeQuery(specificNonTerminalNode);  ///
 
       if ((generalNode !== null) && (specificNode !== null)) {
-        nodeUnified = unify(generalNode, specificNode, ...remainingArguments);
+        nodeUnifies = unify(generalNode, specificNode, ...remainingArguments);
 
         return true;
       }
     });
 
-    nonTerminalNodeUnified = nodeUnified; ///
+    nonTerminalNodeUnifies = nodeUnifies; ///
 
-    return nonTerminalNodeUnified;
+    return nonTerminalNodeUnifies;
   }
 
   unifyChildNodesAhead(index, generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let childNodesUnified;
+    let childNodesUnify;
 
     const unifyAhead = remainingArguments.pop(), ///
           generalChildNodesLength = generalChildNodes.length;
 
     if (index === generalChildNodesLength) {
-      const unifiedAhead = unifyAhead();
+      const unifiesAhead = unifyAhead();
 
-      childNodesUnified = unifiedAhead; ///
+      childNodesUnify = unifiesAhead; ///
     } else {
       const generalChildNode = generalChildNodes[index],
             specificChildNode = specificChildNodes[index],
             generalNode = generalChildNode, ///
             specificNode = specificChildNode, ///
-            nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments, () => {
+            nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments, () => {
               remainingArguments.push(unifyAhead); ///
 
               const aheadIndex = index + 1,
-                    childNodesUnifiedAhead = this.unifyChildNodesAhead(aheadIndex, generalChildNodes, specificChildNodes, ...remainingArguments);
+                    childNodesUnifyAhead = this.unifyChildNodesAhead(aheadIndex, generalChildNodes, specificChildNodes, ...remainingArguments);
 
-              return childNodesUnifiedAhead;
+              return childNodesUnifyAhead;
             });
 
-      childNodesUnified = nodeUnified;  ///
+      childNodesUnify = nodeUnifies;  ///
     }
 
-    return childNodesUnified;
+    return childNodesUnify;
   }
 }

package/src/utilities/brackets.js

@@ -15,7 +15,7 @@ export function stripBracketsFromTerm(term, context) {
     const { Term } = dom,
           termNode = bracketedTermChildNode;  ///
 
-    term = Term.fromStatementNode(termNode, context);
+    term = Term.fromTermNode(termNode, context);
   }
 
   return term;

package/src/utilities/release.js

@@ -1,7 +1,7 @@
 "use strict";
 
 function verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap) {
-  let releaseVerified = false;
+  let releaseVerifies = false;
 
   const releaseContext = releaseContextMap[releaseName];
 
@@ -9,37 +9,37 @@ function verifyRelease(releaseName, dependentName, dependentReleased, releaseCon
     const released = releaseContext.isReleased();
 
     if (released) {
-      releaseVerified = true;
+      releaseVerifies = true;
     } else {
       if (dependentReleased) {
-        releaseContext.warning(`The '${releaseName}' project cannot be verified because its '${dependentName}' dependent is a package.`);
+        releaseContext.warning(`The '${releaseName}' project cannot be verifies because its '${dependentName}' dependent is a package.`);
       } else {
         const dependentName = releaseName,  ///
               dependentReleased = released, ///
-              dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap);
+              dependencyReleasesVVerifies = verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap);
 
-        if (dependencyReleasesVVerified) {
-          let releaseContextVerified;
+        if (dependencyReleasesVVerifies) {
+          const releaseContextVerified = releaseContext.isVerified();
 
-          releaseContextVerified = releaseContext.isVerified();
-
-          if (!releaseContextVerified) {
+          if (releaseContextVerified) {
+            releaseVerifies = true;
+          } else {
             releaseContext.info(`Verifying the '${releaseName}' project...`);
 
-            releaseContextVerified = releaseContext.verify();
+            const releaseContextVerifies = releaseContext.verify();
 
-            if (releaseContextVerified) {
+            if (releaseContextVerifies) {
               releaseContext.info(`...verified the '${releaseName}' project.`);
+
+              releaseVerifies = true;
             }
           }
-
-          releaseVerified = releaseContextVerified; ///
         }
       }
     }
   }
 
-  return releaseVerified;
+  return releaseVerifies;
 }
 
 export default {
@@ -48,15 +48,15 @@ export default {
 
 function verifyDependencyReleases(releaseContext, dependentName, dependentReleased, releaseContextMap) {
   const dependencies = releaseContext.getDependencies(),
-        dependencyReleasesVVerified = dependencies.everyDependency((dependency) => {
+        dependencyReleasesVVerifies = dependencies.everyDependency((dependency) => {
           const name = dependency.getName(),
                 releaseName = name, ///
-                releaseVerified = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
+                releaseVerifies = verifyRelease(releaseName, dependentName, dependentReleased, releaseContextMap);
 
-          if (releaseVerified) {
+          if (releaseVerifies) {
             return true;
           }
         });
 
-  return dependencyReleasesVVerified;
+  return dependencyReleasesVVerifies;
 }

package/src/utilities/subproof.js

@@ -3,7 +3,7 @@
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   const suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext),
         lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, fileContext),
-        subproofString = `[${suppositionStatementsOrNonsenseString}]...${lastStatementOrNonsenseString}`;
+        subproofString = `[${suppositionStatementsOrNonsenseString}] ... ${lastStatementOrNonsenseString}`;
 
   return subproofString;
 }

package/src/utilities/type.js

@@ -5,7 +5,7 @@ import { objectType } from "../dom/type";
 export function stringFromTypeNameNameAndSuperTypes(typeName, superTypes) {
   const superTypesString = superTypesStringFromSuperTypes(superTypes),
         string = (superTypesString !== null) ?
-                   `${typeName}:${superTypesString}` :
+                   `'${typeName}':${superTypesString}` :
                      typeName; ///
 
   return string;