occam-verify-cli 1.0.984 → 1.0.985

package/src/element/conclusion.js

@@ -1,185 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateConclusion } from "../process/instantiate";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { elide, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
-
-export default define(class Conclusion extends Element {
-  constructor(context, string, node, breakPoint, statement) {
-    super(context, string, node, breakPoint);
-
-    this.statement = statement;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  getConclusionNode() {
-    const node = this.getNode(),
-          conclusionNode = node;  ///
-
-    return conclusionNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const conclusionString = this.getString();  ///
-
-    context.trace(`Verifying the '${conclusionString}' conclusion...`);
-
-    if (this.statement !== null) {
-      declare((context) => {
-        elide((context) => {
-          const validates = this.validate(context);
-
-          if (validates) {
-            verifies = true;
-          }
-        }, context);
-      }, context);
-    } else {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${conclusionString}' conclusion.`);
-    }
-
-    return verifies;
-  }
-
-  validate(context) {
-    let validates = false;
-
-    const conclusionString = this.getString();  ///
-
-    context.trace(`Validating the '${conclusionString}' conclusion...`);
-
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
-
-      if (statementValidates) {
-        validates = true;
-      }
-
-      if (validates) {
-        this.commit(context);
-      }
-    }, context);
-
-    if (validates) {
-      context.debug(`...validated the '${conclusionString}' conclusion.`);
-    }
-
-    return validates;
-  }
-
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const conclusionString = this.getString();  ///
-
-    context.trace(`Validating the '${conclusionString}' conclusion's statement...`);
-
-    const statement = this.statement.validate(context);
-
-    if (statement !== null) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.trace(`...validated the '${conclusionString}' conclusion's statement.`);
-    }
-
-    return statementValidates;
-  }
-
-  unifyStep(step, context) {
-    let stepUnifies = false;
-
-    const stepString = step.getString(),
-          conclusionString = this.getString();  ///
-
-    context.trace(`Unifying the '${stepString}' step with the '${conclusionString}' conclusion...`);
-
-    const stepContext = step.getContext(),
-          conclusionContext = this.getContext(),
-          generalContext = conclusionContext, ///
-          specificContext = stepContext;  ///
-
-    reconcile((specificContext) => {
-      const statement = step.getStatement(),
-            statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
-
-      if (statementUnifies) {
-        specificContext.commit(context);
-
-        stepUnifies = true;
-      }
-    }, specificContext);
-
-    if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${conclusionString}' conclusion.`);
-    }
-
-    return stepUnifies;
-  }
-
-  toJSON() {
-    const context = this.getContext();
-
-    return serialise((context) => {
-      const string = this.getString();
-
-      let breakPoint;
-
-      breakPoint = this.getBreakPoint();
-
-      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-      breakPoint = breakPointJSON;  ///
-
-      const json = {
-        context,
-        string,
-        breakPoint
-      };
-
-      return json;
-    }, context);
-  }
-
-  static name = "Conclusion";
-
-  static fromJSON(json, context) {
-    let conclusion;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              conclusionNode = instantiateConclusion(string, context),
-              node = conclusionNode,  ///
-              breakPoint = breakPointFromJSON(json),
-              statement = statementFromConclusionNode(conclusionNode, context);
-
-        conclusion = new Conclusion(context, string, node, breakPoint, statement);
-      }, json, context);
-    }, context);
-
-    return conclusion;
-  }
-});
-
-function statementFromConclusionNode(conclusionNode, context) {
-  const statementNode = conclusionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/constructor/bracketed.js

@@ -1,68 +0,0 @@
-"use strict";
-
-import Constructor from "../constructor";
-
-import { define } from "../../elements";
-import { termFromTermNode } from "../../utilities/element";
-
-export default define(class BracketedConstructor extends Constructor {
-  getBracketedConstructorNode() {
-    const node = this.getNode(),
-          bracketedConstructorNode = node;  ///
-
-    return bracketedConstructorNode;
-  }
-
-  unifyTerm(term, context, validateForwards) {
-    let termUnifies;
-
-    const termString = term.getString();
-
-    context.trace(`Unifying the '${termString}' term with the bracketed constructor...`);
-
-    termUnifies = super.unifyTerm(term, context, (term, context) => {
-      let validatesForwards = false;
-
-      const bracketedTerm = term, ///
-            bracketedTermNode = bracketedTerm.getNode(),
-            singularTermNode = bracketedTermNode.getSingularTermNode();
-
-      if (singularTermNode !== null) {
-        const bracketlessTermNode = singularTermNode; ///
-
-        let bracketlessTerm;
-
-        bracketlessTerm = termFromTermNode(bracketlessTermNode, context);
-
-        bracketlessTerm = bracketlessTerm.validate(context, (bracketlessTerm, context) => {  ///
-          let validatesForwards;
-
-          const type = bracketlessTerm.getType(),
-                provisional = bracketlessTerm.isProvisional();
-
-          bracketedTerm.setType(type);
-
-          bracketedTerm.setProvisional(provisional);
-
-          validatesForwards = validateForwards(bracketedTerm, context);
-
-          return validatesForwards;
-        });
-
-        if (bracketlessTerm !== null) {
-          validatesForwards = true;
-        }
-      }
-
-      return validatesForwards;
-    });
-
-    if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the bracketed constructor.`);
-    }
-
-    return termUnifies;
-  }
-
-  static name = "BracketedConstructor";
-});

package/src/element/constructor.js

@@ -1,188 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateConstructor } from "../process/instantiate";
-import { termFromConstructorNode } from "../utilities/element";
-import { unifyTermWithConstructor } from "../process/unify";
-import { validateTermAsConstructor } from "../process/validate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class Constructor extends Element {
-  constructor(context, string, node, breakPoint, term, type) {
-    super(context, string, node, breakPoint);
-
-    this.term = term;
-    this.type = type;
-  }
-
-  getTerm() {
-    return this.term;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getConclusionNode() {
-    const node = this.getNode(),
-          constructorNode = node;  ///
-
-    return constructorNode;
-  }
-
-  getString(includeType = true) {
-    let string;
-
-    if (includeType) {
-      const termString = this.term.getString(),
-            typeString = this.type.getString();
-
-      string = `${termString}.${typeString}`;
-    } else {
-      string = super.getString();
-    }
-
-    return string;
-  }
-
-  setType(type) {
-    this.type = type;
-  }
-
-  validate(context) {
-    let validates = false;
-
-    const includeType = false,
-          constructorString = this.getString(includeType);
-
-    context.trace(`Validating the '${constructorString}' constructor...`);
-
-    attempt((context) => {
-      const termValidates = this.validateTerm(context);
-
-      if (termValidates) {
-        validates = true;
-      }
-
-      if (validates) {
-        this.commit(context);
-      }
-    }, context);
-
-    if (validates) {
-      context.debug(`...validated the '${constructorString}' constructor.`);
-    }
-
-    return validates;
-  }
-
-  validateTerm(context) {
-    let termValidates = false;
-
-    const includeType = false,
-          constructorString = this.getString(includeType);
-
-    context.trace(`Validating the '${constructorString}' constructor's term...`);
-
-    const termValidatesAsConstructor = validateTermAsConstructor(this.term, context);
-
-    if (termValidatesAsConstructor) {
-      termValidates = true;
-    }
-
-    if (termValidates) {
-      context.debug(`...validated the '${constructorString}' constructor's term.`);
-    }
-
-    return termValidates;
-  }
-
-  unifyTerm(term, context, validateForwards) {
-    let termUnifies = false;
-
-    const termString = term.getString(),
-          includeType = false,
-          constructorString = this.getString(includeType);  ///
-
-    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
-
-    const constructor = this, ///
-          constructorContext = constructor.getContext(),
-          generalContext = constructorContext,  ///
-          specifiContext = context, ///
-          termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);
-
-    if (termUnifiesWithConstructor) {
-      const provisional = this.type.isProvisional();
-
-      term.setType(this.type);
-
-      term.setProvisional(provisional);
-
-      const validatesForwards = validateForwards(term, context);
-
-      if (validatesForwards) {
-        termUnifies = true;
-      }
-    }
-
-    if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);
-    }
-
-    return termUnifies;
-  }
-
-  toJSON() {
-    const context = this.getContext();
-
-    return serialise((context) => {
-      const includeType = false,
-            typeJSON = typeToTypeJSON(this.type),
-            string = this.getString(includeType);
-
-      let breakPoint;
-
-      breakPoint = this.getBreakPoint();
-
-      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-      breakPoint = breakPointJSON;  ///
-
-      const type = typeJSON,  ///
-            json = {
-              context,
-              string,
-              breakPoint,
-              type
-            };
-
-      return json;
-    }, context);
-  }
-
-  static name = "Constructor";
-
-  static fromJSON(json, context) {
-    let constructor;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              constructorNode = instantiateConstructor(string, context),
-              node = constructorNode, ///
-              breakPoint = breakPointFromJSON(json),
-              term = termFromConstructorNode(constructorNode, context),
-              type = typeFromJSON(json, context);
-
-        constructor = new Constructor(context, string, node, breakPoint, term, type);
-      }, json, context);
-    }, context);
-
-    return constructor;
-  }
-});

package/src/element/declaration/combinator.js

@@ -1,66 +0,0 @@
-"use strict";
-
-import Declaration from "../declaration";
-
-import { define } from "../../elements";
-
-export default define(class CombinatorDeclaration extends Declaration {
-  constructor(context, string, node, breakPoint, combinator) {
-    super(context, string, node, breakPoint);
-
-    this.combinator = combinator;
-  }
-
-  getCombinator() {
-    return this.combinator;
-  }
-
-  getCombinatorDeclarationNode() {
-    const node = this.getNode(),
-          combinatorDeclarationNode = node; ///
-
-    return combinatorDeclarationNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
-
-    const combinatorDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
-
-    const combinatorValidates = this.validateCombinator(context);
-
-    if (combinatorValidates) {
-      context.addCombinator(this.combinator);
-
-      verifies = true;
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`);
-    }
-
-    return verifies;
-  }
-
-  validateCombinator(context) {
-    let combinatorValidates;
-
-    const combinatorDeclarationString = this.getString();  ///
-
-    context.trace(`Validating the '${combinatorDeclarationString}' combinator declaration's combinator...`);
-
-    combinatorValidates = this.combinator.validate(context);
-
-    if (combinatorValidates) {
-      context.debug(`...validated the '${combinatorDeclarationString}' combinator declaration's combinator.`);
-    }
-
-    return combinatorValidates;
-  }
-
-  static name = "CombinatorDeclaration";
-});