occam-verify-cli 1.0.984 → 1.0.985

package/src/ruleNames.js

@@ -1,86 +0,0 @@
-"use strict";
-
-export const RULE_RULE_NAME = "rule";
-export const STEP_RULE_NAME = "step";
-export const TERM_RULE_NAME = "term";
-export const TYPE_RULE_NAME = "type";
-export const TYPES_RULE_NAME = "types";
-export const LEMMA_RULE_NAME = "lemma";
-export const AXIOM_RULE_NAME = "axiom";
-export const ERROR_RULE_NAME = "error";
-export const FRAME_RULE_NAME = "frame";
-export const PROOF_RULE_NAME = "proof";
-export const LABEL_RULE_NAME = "label";
-export const LABELS_RULE_NAME = "labels";
-export const THEOREM_RULE_NAME = "theorem";
-export const PREMISE_RULE_NAME = "premise";
-export const SECTION_RULE_NAME = "section";
-export const ARGUMENT_RULE_NAME = "argument";
-export const PROPERTY_RULE_NAME = "property";
-export const EQUALITY_RULE_NAME = "equality";
-export const VARIABLE_RULE_NAME = "variable";
-export const SUBPROOF_RULE_NAME = "subproof";
-export const DOCUMENT_RULE_NAME = "document";
-export const RULE_BODY_RULE_NAME = "ruleBody";
-export const META_TYPE_RULE_NAME = "metaType";
-export const SIGNATURE_RULE_NAME = "signature";
-export const PARAMETER_RULE_NAME = "parameter";
-export const DEDUCTION_RULE_NAME = "deduction";
-export const JUDGEMENT_RULE_NAME = "judgement";
-export const REFERENCE_RULE_NAME = "reference";
-export const STATEMENT_RULE_NAME = "statement";
-export const META_LEMMA_RULE_NAME = "metaLemma";
-export const AXIOM_BODY_RULE_NAME = "axiomBody";
-export const LEMMA_BODY_RULE_NAME = "lemmaBody";
-export const COMBINATOR_RULE_NAME = "combinator";
-export const CONCLUSION_RULE_NAME = "conclusion";
-export const CONJECTURE_RULE_NAME = "conjecture";
-export const DERIVATION_RULE_NAME = "derivation";
-export const HYPOTHESIS_RULE_NAME = "hypothesis";
-export const ASSUMPTION_RULE_NAME = "assumption";
-export const PLACEHOLDER_RULE_NAME = "_"; ///
-export const RULE_HEADER_RULE_NAME = "ruleHeader";
-export const TYPE_PREFIX_RULE_NAME = "typePrefix";
-export const SUPPOSITION_RULE_NAME = "supposition";
-export const CONSTRUCTOR_RULE_NAME = "constructor";
-export const METATHEOREM_RULE_NAME = "metatheorem";
-export const EQUIVALENCE_RULE_NAME = "equivalence";
-export const AXIOM_HEADER_RULE_NAME = "axiomHeader";
-export const LEMMA_HEADER_RULE_NAME = "lemmaHeader";
-export const THEOREM_BODY_RULE_NAME = "theoremBody";
-export const METAVARIABLE_RULE_NAME = "metavariable";
-export const EQUIVALENCES_RULE_NAME = "equivalences";
-export const META_ARGUMENT_RULE_NAME = "metaArgument";
-export const QUALIFICATION_RULE_NAME = "qualification";
-export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
-export const SUB_DERIVATION_RULE_NAME = "subDerivation";
-export const TYPE_ASSERTION_RULE_NAME = "typeAssertion";
-export const THEOREM_HEADER_RULE_NAME = "theoremHeader";
-export const META_LEMMA_BODY_RULE_NAME = "metaLemmaBody";
-export const CONJECTURE_BODY_RULE_NAME = "conjectureBody";
-export const METATHEOREM_BODY_RULE_NAME = "metatheoremBody";
-export const META_LEMMA_HEADER_RULE_NAME = "metaLemmaHeader";
-export const CONJECTURE_HEADER_RULE_NAME = "conjectureHeader";
-export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
-export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
-export const TERM_SUBSTITUTION_RULE_NAME = "termSubstitution";
-export const METATHEOREM_HEADER_RULE_NAME = "metatheoremHeader";
-export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
-export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
-export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";
-export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
-export const PROCEDURE_REFERENCE_RULE_NAME = "procedureReference";
-export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
-export const SIGNATURE_ASSERTION_RULE_NAME = "signatureAssertion";
-export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
-export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
-export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
-export const META_LEVEL_ASSUMPTION_RULE_NAME = "metaLevelAssumption";
-export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
-export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
-export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
-export const TYPE_PREFIX_DECLARATION_RULE_NAME = "typePrefixDeclaration";
-export const SIMPLE_TYPE_DECLARATION_RULE_NAME = "simpleTypeDeclaration";
-export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
-export const COMPLEX_TYPE_DECLARATION_RULE_NAME = "complexTypeDeclaration";
-export const METAVARIABLE_DECLARATION_RULE_NAME = "metavariableDeclaration";

package/src/tokenTypes.js

@@ -1,4 +0,0 @@
-"use strict";
-
-export const NAME_TOKEN_TYPE = "name";
-export const IDENTIFIER_TOKEN_TYPE = "identifier";

package/src/utilities/assignment.js

@@ -1,57 +0,0 @@
-"use strict";
-
-import { variableFromVariableNode } from "../utilities/element";
-
-export function variableAssignmentFromTermAndType(term, type, context) {
-  let variableAssignment = (context) => {
-    ///
-  };
-
-  const termSingular = term.isSingular();
-
-  if (termSingular) {
-    const termType = term.getType(),
-          termTypeEqualToType = termType.isEqualTo(type),
-          termTypeSuperTypeOfType = termType.isSuperTypeOf(type);
-
-    if (false) {
-      ///
-    } else if (termTypeEqualToType) {
-      const termProvisional = term.isProvisional();
-
-      if (termProvisional) {
-        const type = term.getType(),
-              variableNode = term.getVariableNode(),
-              variable = variableFromVariableNode(variableNode, context),
-              provisional = false;
-
-        variable.setType(type);
-
-        variable.setProvisional(provisional);
-
-        variableAssignment = (context) => {
-          const declaredVariable = variable;  ///
-
-          context.addDeclaredVariable(declaredVariable);
-        };
-      }
-    } else if (termTypeSuperTypeOfType) {
-      const termEstablished = term.isEstablished();
-
-      if (termEstablished) {
-        const variableNode = term.getVariableNode(),
-              variable = variableFromVariableNode(variableNode, context);
-
-        variable.setType(type);
-
-        variableAssignment = (context) => {
-          const declaredVariable = variable;  ///
-
-          context.addDeclaredVariable(declaredVariable);
-        };
-      }
-    }
-  }
-
-  return variableAssignment;
-}

package/src/utilities/bnf.js

@@ -1,20 +0,0 @@
-"use strict";
-
-import { BNFLexer } from "occam-lexers";
-import { BNFParser } from "occam-parsers";
-import { arrayUtilities } from "necessary";
-
-const { first } = arrayUtilities;
-
-const bnfLexer = BNFLexer.fromNothing(),
-      bnfParser = BNFParser.fromNothing();
-
-export function ruleFromRuleName(ruleName) {
-  const bnf = ` _ ::= ${ruleName}... <END_OF_LINE> ; `,
-        tokens = bnfLexer.tokensFromBNF(bnf),
-        rules = bnfParser.rulesFromTokens(tokens),
-        firstRule = first(rules),
-        rule = firstRule; ///
-
-  return rule;
-}

package/src/utilities/brackets.js

@@ -1,87 +0,0 @@
-"use strict";
-
-import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
-import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
-import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
-
-export function stripBracketsFromTerm(term, context) {
-  const termNode = term.getNode(),
-        bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
-
-  if (bracketedTermChildNode !== null) {
-    const termNode = bracketedTermChildNode;  ///
-
-    term = termFromTermNode(termNode, context);
-  }
-
-  return term;
-}
-
-export function stripBracketsFromTermNode(termNode) {
-  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
-
-  if (bracketedTermChildNode !== null) {
-    termNode = bracketedTermChildNode;  ///
-  }
-
-  return termNode;
-}
-
-export function stripBracketsFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
-
-  if (bracketedStatementChildNode !== null) {
-    const statementNode = bracketedStatementChildNode;  ///
-
-    statement = statementFromStatementNode(statementNode, context);
-  }
-
-  return statement;
-}
-
-export function stripBracketsFromStatementNode(statementNode) {
-  const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
-
-  if (bracketedStatementChildNode !== null) {
-    statementNode = bracketedStatementChildNode;  ///
-  }
-
-  return statementNode;
-}
-
-function bracketedTermChildNodeFromTermNode(termNode) {
-  let bracketedTermChildNode = null;
-
-  const depth = BRACKETED_TERM_DEPTH,
-        bracketedConstructor = bracketedConstructorFromNothing(),
-        bracketedConstructorTerm = bracketedConstructor.getTerm(),
-        bracketedConstructorTermNode = bracketedConstructorTerm.getNode(),
-        termNodeMatchBracketedConstructorNode = termNode.match(bracketedConstructorTermNode, depth);
-
-  if (termNodeMatchBracketedConstructorNode) {
-    const singularTermNode = termNode.getSingularTermNode();
-
-    bracketedTermChildNode = singularTermNode;  ///
-  }
-
-  return bracketedTermChildNode;
-}
-
-function bracketedStatementChildNodeFromStatementNode(statementNode) {
-  let bracketedStatementChildNode = null;
-
-  const depth = BRACKETED_STATEMENT_DEPTH,
-        bracketedCombinator = bracketedCombinatorFromNothing(),
-        bracketedCombinatorStatement = bracketedCombinator.getStatement(),
-        bracketedCombinatorStatementnNode = bracketedCombinatorStatement.getNode(),
-        statementNodeMatchBracketedCombinatorStatementNode = statementNode.match(bracketedCombinatorStatementnNode, depth);
-
-  if (statementNodeMatchBracketedCombinatorStatementNode) {
-    const singularStatementNode = statementNode.getSingularStatementNode();
-
-    bracketedStatementChildNode = singularStatementNode;  ///
-  }
-
-  return bracketedStatementChildNode;
-}

package/src/utilities/breakPoint.js

@@ -1,29 +0,0 @@
-"use strict";
-
-import { BreakPoint } from "occam-languages";
-
-export function breakPointFromJSON(json) {
-  let breakPoint;
-
-  ({ breakPoint } = json);
-
-  if (breakPoint !== null) {
-    const breakPointJSON = breakPoint;  ///
-
-    json = breakPointJSON;  ///
-
-    breakPoint = BreakPoint.fromJSON(json);  ///
-  }
-
-  return breakPoint;
-}
-
-export function breakPointToBreakPointJSON(breakPoint) {
-  let breakPointJSON = null;
-
-  if (breakPoint !== null) {
-    breakPointJSON = breakPoint.toJSON();
-  }
-
-  return breakPointJSON;
-}

package/src/utilities/context.js

@@ -1,223 +0,0 @@
-"use strict";
-
-import MnemicContext from "../context/mnemic";
-import NestedContext from "../context/nested";
-import TheticContext from "../context/thetic";
-import AphasicContext from "../context/aphasic";
-import BoundedContext from "../context/bounded";
-import NominalContext from "../context/nominal";
-import LiteralContext from "../context/literal";
-import LiminalContext from "../context/liminal";
-import PhanericContext from "../context/phaneric";
-import IllativeContext from "../context/illative";
-import BranchingContext from "../context/branching";
-import NominalFileContext from "../context/file/nominal";
-
-import { mnemicContextFromJSON, mnemicContextsFromJSON, mnemicContextToMnemicContextJSON, mnemicContextsToMnemicContextsJSON } from "../utilities/json";
-
-export function evaluate(procedure, terms) {
-  const context = procedure.getContext();
-
-  return procedure.call(terms, context);
-}
-
-export function ground(innerFunction) {
-  let context;
-
-  const nominalContext = NominalContext.fromNothing();
-
-  context = nominalContext; ///
-
-  const literalContext = LiteralContext.fromNothing(context);
-
-  context = literalContext;  ///
-
-  return innerFunction(context);
-}
-
-export function declare(innerFunction, context) {
-  const theticContext = TheticContext.fromNothing(context);
-
-  context = theticContext;  ///
-
-  return innerFunction(context);
-}
-
-export function derive(innerFunction, context) {
-  const illativeContext = IllativeContext.fromNothing(context);
-
-  context = illativeContext;  ///
-
-  return innerFunction(context);
-}
-
-export function elide(innerFunction, context) {
-  const aphasicContext = AphasicContext.fromNothing(context);
-
-  context = aphasicContext;  ///
-
-  return innerFunction(context);
-}
-
-export function enclose(innerFunction, context) {
-  const boundedContext = BoundedContext.fromNothing(context);
-
-  context = boundedContext;  ///
-
-  return innerFunction(context);
-}
-
-export function encapsulate(innerFunction, metaLevelAssumptions, context) {
-  const boundedContext = BoundedContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
-
-  context = boundedContext;  ///
-
-  return innerFunction(context);
-}
-
-export function choose(innerFunction, context) {
-  const branchingContext = BranchingContext.fromNothing(context);
-
-  context = branchingContext;  ///
-
-  return innerFunction(context);
-}
-
-export function descend(innerFunction, context) {
-  const nestedContext = NestedContext.fromNothing(context);
-
-  context = nestedContext;  ///
-
-  return innerFunction(context);
-}
-
-export function ablate(innerFunction, context) {
-  const unreleased = context.isUnreleased();
-
-  if (unreleased) {
-    context = ablateContext(context); ///
-  }
-
-  return innerFunction(context);
-}
-
-export function attempt(innerFunction, context) {
-  const unreleased = context.isUnreleased();
-
-  if (unreleased) {
-    const mnemicContext = MnemicContext.fromNothing(context);
-
-    context = mnemicContext;  ///
-  }
-
-  return innerFunction(context);
-}
-
-export function reconcile(innerFunction, context) {
-  const liminalContext = LiminalContext.fromNothing(context);
-
-  context = liminalContext;  ///
-
-  return innerFunction(context);
-}
-
-export function serialise(innerFunction, context) {
-  const mnemicContext = context, ///
-        mnemicContextJSON = mnemicContextToMnemicContextJSON(mnemicContext),
-        contextJSON = mnemicContextJSON; ///
-
-  context = contextJSON;  ///
-
-  return innerFunction(context);
-}
-
-export function unserialise(innerFunction, json, context) {
-  const mnemicContext = mnemicContextFromJSON(json, context);
-
-  context = mnemicContext; ///
-
-  return innerFunction(json, context);
-}
-
-export function unserialises(innerFunction, json, context) {
-  const mnemicContexts = mnemicContextsFromJSON(json, context),
-        contexts = mnemicContexts; ///
-
-  return innerFunction(json, ...contexts);
-}
-
-export function instantiate(innerFunction, context) {
-  const literalContext = LiteralContext.fromNothing(context);
-
-  context = literalContext;  ///
-
-  return innerFunction(context);
-}
-
-export function manifest(innerFunction, ...contexts) {
-  const phanericContext = PhanericContext.fromContexts(contexts),
-        context = phanericContext;  ///
-
-  return innerFunction(context);
-}
-
-export function attempts(innerFunction, ...contexts) {
-  contexts = contexts.map((context) => {  ///
-    const unreleased = context.isUnreleased();
-
-    if (unreleased) {
-      const mnemicContext = MnemicContext.fromNothing(context);
-
-      context = mnemicContext;  ///
-    }
-
-    return context;
-  });
-
-  return innerFunction(...contexts);
-}
-
-export function serialises(innerFunction, ...contexts) {
-  const mnemicContexts = contexts, ///
-        mnemicContextsJSON = mnemicContextsToMnemicContextsJSON(mnemicContexts),
-        contextsJSON = mnemicContextsJSON; ///
-
-  contexts = contextsJSON;  ///
-
-  return innerFunction(...contexts);
-}
-
-export function ablates(innerFunction, ...contexts) {
-  contexts = contexts.map((context) => {  ///
-    const unreleased = context.isUnreleased();
-
-    if (unreleased) {
-      context = ablateContext(context); ///
-    }
-
-    return context;
-  });
-
-  return innerFunction(...contexts);
-}
-
-function ablateContext(context) {
-    let contextGroundedContext = isContextGroundedContext(context);
-
-    while (!contextGroundedContext) {
-      context = context.getContext();
-
-      contextGroundedContext = isContextGroundedContext(context);
-    }
-
-  return context;
-}
-
-function isContextGroundedContext(context) {
-  const contextTheticContext = (context instanceof TheticContext),
-        contextIllativeContext = (context instanceof IllativeContext),
-        contextNominalFileContext = (context instanceof NominalFileContext),
-        contextGroundedContext = (contextTheticContext || contextIllativeContext || contextNominalFileContext);
-
-  return contextGroundedContext;
-}