yukigo-prolog-parser 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo-prolog-parser",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,13 @@
     "moo": "^0.5.2",
     "moo-ignore": "^2.5.3",
     "nearley": "^2.20.1",
-    "yukigo-ast": "0.1.0"
+    "yukigo-ast": "^0.2.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "devDependencies": {
     "@types/chai": "^5.2.2",

package/src/index.ts

@@ -1 +1,82 @@
-export * from "./parser/parser.js"
+import { AST, Expression, Rule, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./parser/grammar.js";
+import { Token } from "moo";
+import { stdCode } from "./std.js";
+
+class UnexpectedToken extends Error {
+  constructor(token: Token) {
+    super(
+      `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`
+    );
+  }
+}
+class AmbiguityError extends Error {
+  constructor(amountAST: number) {
+    super(
+      `Parser: Too much ambiguity. ${amountAST} ASTs parsed. Output not generated.`
+    );
+  }
+}
+
+export type HaskellConfig = {
+  typecheck: boolean;
+};
+
+export class YukigoPrologParser implements YukigoParser {
+  public errors: string[] = [];
+  private std: AST;
+  constructor(std: string = stdCode) {
+    this.errors = [];
+    this.std = this.feedParser(std);
+  }
+  public parse(code: string): AST {
+    const result = this.feedParser(code);
+    const ast = groupRuleDeclarations(this.std.concat(result));
+    return ast;
+  }
+  public parseExpression(code: string): Expression {
+    const expr = this.feedParser(code)[0];
+    return expr;
+  }
+  private feedParser(code: string): any {
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (error) {
+      if ("token" in error) throw new UnexpectedToken(error.token);
+      throw error;
+    }
+    const { results } = parser;
+    if (results.length > 1) throw new AmbiguityError(results.length);
+    if (results.length == 0) return [];
+    return results[0];
+  }
+}
+
+export function groupRuleDeclarations(ast: AST): AST {
+  const groups: Record<string, Rule[]> = {};
+  const others: AST = [];
+
+  for (const node of ast) {
+    if (node instanceof Rule) {
+      const name = node.identifier.value;
+      if (!groups[name]) {
+        groups[name] = [];
+      }
+      groups[name].push(node);
+    } else {
+      others.push(node);
+    }
+  }
+
+  // Merge equations for each rule
+  const ruleGroups: Rule[] = Object.values(groups).map((rules) => {
+    const identifier = rules[0].identifier;
+    const allEquations = rules.flatMap((r) => r.equations);
+    return new Rule(identifier, allEquations, identifier.loc);
+  });
+
+  return [...others, ...ruleGroups];
+}

package/src/parser/grammar.ne

@@ -1,166 +1,223 @@
-@{%
-import { 
-    NumberPrimitive, 
-    StringPrimitive, 
-    Rule, 
-    Fact, 
-    Query,
-    ConsExpression,
-    ArithmeticBinaryOperation,
-    ArithmeticUnaryOperation,
-    ComparisonOperation,
-    Exist, 
-    Not, 
-    Findall, 
-    Sequence,
-    If,
-    Call,
-    Forall, 
-    SymbolPrimitive, 
-    AssignOperation,
-    UnifyOperation,
-    VariablePattern, 
-    FunctorPattern, 
-    ConsPattern, 
-    ListPattern, 
-    LiteralPattern,
-    WildcardPattern,
-    TuplePattern
- } from "yukigo-ast"
-
-import { PrologLexer } from "./lexer.js"
-
-const asSequence = (d) => d.length === 1 ? d[0] : new Sequence(d);
-
-%}
-@preprocessor typescript
-@lexer PrologLexer
-
-program -> (clause _):* {% (d) => d[0].map(x => x[0]).filter(x => x !== null).flat(Infinity) %}
-
-clause -> (fact | rule | query) {% (d) => d[0][0] %}
-
-fact -> any_atom arguments:? _ %period {% (d) => new Fact(d[0], d[1] ?? []) %}
-
-rule -> any_atom arguments:? _ %colonDash _ body _ %period {% (d) => new Rule(d[0], d[1] ?? [], d[5]) %}
-
-query -> %queryOp _ body _ %period {% (d) => new Query(d[2]) %}
-
-body -> expression (_ (%comma | %semicolon) _ expression):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
-
-expression -> 
-    (conditional | forall | findall | unification | assignment | comparison | not | exist) {% (d) => d[0][0] %}
-    | "(" _ expression _ ")" {% (d) => d[2] %}
-
-conditional -> "(" _ body _ "->" _ body _ %semicolon _ body _ ")"  {% (d) => 
-    new If(
-        asSequence(d[2]),  
-        asSequence(d[6]),   
-        asSequence(d[10])
-    ) 
-%}
-
-forall -> %forallRule "(" _ expression _ %comma _ expression _ ")" {% (d) => new Forall(d[3], d[7]) %}
-
-findall -> %findallRule "(" _ expression _ %comma _ expression _ %comma _ expression _ ")" {% (d) => new Findall(d[3], d[7], d[11]) %}
-
-not -> 
-    %notOperator _ expression {% (d) => new Not([d[2]]) %}
-    | %notOperator _ "(" _ "(" _ body _  ")" _ ")" {% (d) => new Not([asSequence(d[6])]) %}
-
-exist -> 
-    "call" %lparen _ pattern_list _ %rparen {% (d) => {
-        const [callee, ...rest] = d[3]
-        return new Call(callee.name, rest)
-    } %}
-    | any_atom arguments:? {% (d, l, reject) => {
-        const val = d[0].value; 
-        if (val === "not" || val === "\\+") return reject;
-        return new Exist(d[0], d[1] ?? []) 
-    } %}
-    | variable {% (d) => new Exist(d[0], []) %}
-    
-
-assignment -> addition _ "is" _ addition {% (d) => new AssignOperation("Assign", d[0], d[4]) %}
-
-unification -> addition _ "=" _ addition {% (d) => new UnifyOperation("Unify", d[0], d[4]) %}
-
-comparison -> 
-    addition _ comparison_op _ addition {% (d) => new ComparisonOperation(d[2], d[0], d[4]) %}
-
-addition ->
-    multiplication _ "+" _ addition {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
-    | multiplication _ "-" _ addition {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
-    | multiplication {% id %}
-
-multiplication ->
-    primary _ "*" _ multiplication {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
-    | primary _ "/" _ multiplication {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
-    | primary {% id %}
-
-primary -> 
-    arithmetic_literal {% id %}
-    | variable {% id %}
-    | strict_atom arguments  {% d => new Exist(d[0], d[1] ?? []) %}
-    | primitiveOperation  {% id %}
-    | cons_expr  {% id %}
-    | "(" _ addition _ ")"  {% d => d[2] %}
-
-cons_expr -> "[" _ primary_list _ %consOp _ expression _ "]" {% (d) => new ConsExpression(d[2], d[6]) %}
-
-primitiveOperation -> 
-    "round" __ addition {% d => new ArithmeticUnaryOperation("Round", d[2]) %}
-    | "abs" __ addition {% d => new ArithmeticUnaryOperation("Absolute", d[2]) %}
-    | "sqrt" __ addition {% d => new ArithmeticUnaryOperation("Sqrt", d[2]) %}
-
-primitiveArguments -> %lparen _ primary_list _ %rparen {% (d) => d[2] %}
-primary_list -> addition (_ %comma _ addition):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
-
-arguments -> %lparen _ pattern_list _ %rparen {% (d) => d[2] %}
-
-pattern_list -> pattern (_ %comma _ pattern):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
-
-pattern -> 
-    variable {% (d) => new VariablePattern(d[0]) %}
-    | structural_literal {% (d) => new LiteralPattern(d[0]) %}
-    | %wildcard {% (d) => new WildcardPattern() %}
-    | any_atom arguments {% (d) => new FunctorPattern(d[0], d[1]) %}
-    | "(" _ pattern_list _ ")" {% (d) => new TuplePattern(d[2]) %}
-    | "[" _ pattern_list _ %consOp _ pattern _ "]" {% (d) => new ConsPattern(d[2].length > 1 ? new ListPattern(d[2]) : d[2][0], new VariablePattern(d[6])) %}
-    | "[" _ pattern_list:? _ "]"  {% (d) => new ListPattern(d[2] ? d[2] : []) %}
-
-variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
-
-strict_atom -> %atom {% (d) => new SymbolPrimitive(d[0].value) %}
-
-any_atom -> (%atom | %op | %comparisonOp) {% (d) => new SymbolPrimitive(d[0][0].value) %}
-
-arithmetic_literal -> 
-    strict_atom {% id %}
-    | %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
-    | %string {% (d) => new StringPrimitive(d[0].value) %}
-
-structural_literal -> 
-    any_atom {% id %}
-    | %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
-    | %string {% (d) => new StringPrimitive(d[0].value) %}
-
-comparison_op ->
-    "=:=" {% d => "Equal" %}
-    | "=\\=" {% d => "NotEqual" %}
-    | "==" {% d => "Same" %}
-    | "\\==" {% d => "NotSame" %}
-    | "\\=" {% d => "NotSame" %}
-    | "@<" {% d => "LessThan" %}
-    | "@=<" {% d => "LessOrEqualThan" %}
-    | "@>" {% d => "GreaterThan" %}
-    | "@>=" {% d => "GreaterOrEqualThan" %}
-    | "<" {% d => "LessThan" %}
-    | "=<" {% d => "LessOrEqualThan" %}
-    | ">" {% d => "GreaterThan" %}
-    | ">=" {% d => "GreaterOrEqualThan" %}
-    | "=@=" {% d => "Same" %}
-    | "\\=@=" {% d => "NotSame" %}
-
-_ -> %WS:*
-__ -> %WS:?
+@{% import { 
+    NumberPrimitive, 
+    StringPrimitive, 
+    Rule, 
+    Fact, 
+    Query,
+    ListPrimitive,
+    ConsExpression,
+    ArithmeticBinaryOperation,
+    ArithmeticUnaryOperation,
+    ComparisonOperation,
+    Exist, 
+    Not, 
+    Findall, 
+    Sequence,
+    UnguardedBody,
+    Equation,
+    If,
+    Call,
+    Forall, 
+    SymbolPrimitive, 
+    AssignOperation,
+    UnifyOperation,
+    VariablePattern, 
+    FunctorPattern, 
+    ConsPattern, 
+    ListPattern, 
+    LogicConstraint,
+    LiteralPattern,
+    WildcardPattern,
+    TuplePattern,
+    Test,
+    Assert,
+    Truth
+ } from "yukigo-ast"
+
+import { PrologLexer } from "./lexer.js"
+
+const asSequence = (d) => {
+    if (d instanceof Sequence) return d;
+    if (Array.isArray(d)) return d.length === 1 ? d[0] : new Sequence(d);
+    return new Sequence([d]);
+};
+
+%}
+@preprocessor typescript
+@lexer PrologLexer
+
+program -> _ (clause _):* {% (d) => d[1].map(x => x[0]).filter(x => x !== null).flat(Infinity) %}
+
+clause -> (fact | rule | query | test_rule) {% (d) => d[0][0] %}
+
+fact -> any_atom arguments:? _ %period {% (d) => new Fact(d[0], d[1] ?? []) %}
+
+rule -> any_atom equation _ %period {% (d) => new Rule(d[0], [d[1]]) %}
+
+test_rule -> %testKeyword %lparen _ structural_literal test_args:? _ %rparen equation _ %period {% (d) => new Test(d[3], d[7].body.sequence, d[4] ? [d[4]] : []) %}
+
+test_args -> _ %comma _ pattern {% (d) => d[3] %}
+
+equation -> arguments:? _ %colonDash _ body {% (d) => new Equation(d[0] || [], new UnguardedBody(new Sequence(d[4])))%}
+
+query -> %queryOp _ body _ %period {% (d) => new Query(d[2]) %}
+
+body -> expression (_ (%comma | %semicolon) _ expression):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
+
+expression -> 
+    (conditional | forall | findall | unification | assignment | comparison | not | exist | assertion) {% (d) => d[0][0] %}
+    | "(" _ body _ ")" {% (d) => new Sequence(d[2]) %}
+
+conditional -> "(" _ body _ "->" _ body _ %semicolon _ body _ ")"  {% (d) => 
+    new If(
+        asSequence(d[2]),  
+        asSequence(d[6]),   
+        asSequence(d[10])
+    )
+%}
+
+forall -> %forallRule "(" _ expression _ %comma _ expression _ ")" {% (d) => new Forall(d[3], d[7]) %}
+
+findall -> %findallRule "(" _ pattern _ %comma _ expression _ %comma _ pattern _ ")" {% (d) => new Findall(d[3], d[7], d[11]) %}
+
+not -> 
+    "not" "(" _ expression _ ")" {% (d) => new Not(asSequence(d[3])) %}
+    | "\\+" _ expression {% (d) => new Not(d[2]) %}
+
+exist -> 
+    "call" %lparen _ pattern_list _ %rparen {% (d) => {
+        const [callee, ...rest] = d[3]
+        return new Call(callee.name, rest)
+    } %}
+    | any_atom arguments:? {% (d, l, reject) => {
+        const val = d[0].value; 
+        if (["not", "\\+", "call", "assertion"].includes(val)) return reject;
+        return new Exist(d[0], d[1] ?? []) 
+    } %}
+    | variable {% (d) => new Exist(d[0], []) %}
+    
+assertion -> "assertion" %lparen _ expression _ %rparen {% (d) => 
+    new Assert(null, new Truth(asSequence(d[3]))) 
+%}
+
+assignment -> 
+    addition _ "is" _ addition {% (d) => 
+        new LogicConstraint(new AssignOperation("Assign", d[0], d[4])) 
+    %}
+
+unification -> addition _ "=" _ addition {% (d) => new LogicConstraint(new UnifyOperation("Unify", d[0], d[4])) %}
+
+comparison -> 
+    addition _ comparison_op _ addition {% (d) => 
+        new LogicConstraint(new ComparisonOperation(d[2], d[0], d[4])) 
+    %}
+
+addition ->
+    multiplication _ "+" _ addition {% (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) %}
+    | multiplication _ "-" _ addition {% (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) %}
+    | multiplication {% id %}
+
+multiplication ->
+    primary _ "*" _ multiplication {% (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) %}
+    | primary _ "/" _ multiplication {% (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) %}
+    | primary {% id %}
+
+primary -> 
+    arithmetic_literal {% id %}
+    | variable {% id %}
+    | "-" _ primary {% (d) => new ArithmeticUnaryOperation("Negation", d[2]) %}
+    | strict_atom arguments  {% (d, l, reject) => {
+        const val = d[0].value;
+        if (["abs", "round", "sqrt", "max", "assertion"].includes(val)) return reject;
+        return new Exist(d[0], d[1] ?? [])
+    } %}
+    | primitiveOperation  {% id %}
+    | cons_expr  {% id %}
+    | list_expr {% id %}
+    | "(" _ addition _ ")"  {% d => d[2] %}
+
+list_expr -> "[" _ primary_list:? _ "]" {% (d) => new ListPrimitive(d[2] || []) %}
+
+cons_expr -> "[" _ primary_list _ %consOp _ addition _ "]" {% (d) => {
+    const heads = d[2];
+    const tail = d[6];
+    let current = tail;
+    for (let i = heads.length - 1; i >= 0; i--) {
+        current = new ConsExpression(heads[i], current);
+    }
+    return current;
+} %}
+
+primitiveOperation -> 
+    "round" __ addition {% d => new ArithmeticUnaryOperation("Round", d[2]) %}
+    | "abs" __ addition {% d => new ArithmeticUnaryOperation("Absolute", d[2]) %}
+    | "sqrt" __ addition {% d => new ArithmeticUnaryOperation("Sqrt", d[2]) %}
+    | "max" "(" _ addition _ "," _ addition _ ")" {% d => new ArithmeticBinaryOperation("Max", d[3], d[7]) %}
+
+primitiveArguments -> %lparen _ primary_list _ %rparen {% (d) => d[2] %}
+primary_list -> addition (_ %comma _ addition):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
+
+arguments -> %lparen _ pattern_list _ %rparen {% (d) => d[2] %}
+
+pattern_list -> pattern (_ %comma _ pattern):* {% (d) => [d[0], ...d[1].map(x => x[3])] %}
+
+pattern -> 
+    infix_pattern {% id %}
+    | primary_pattern {% id %}
+
+primary_pattern ->
+    variable {% (d) => new VariablePattern(d[0]) %}
+    | structural_literal {% (d) => new LiteralPattern(d[0]) %}
+    | %wildcard {% (d) => new WildcardPattern() %}
+    | any_atom arguments {% (d) => new FunctorPattern(d[0], d[1]) %}
+    | "(" _ pattern_list _ ")" {% (d) => new TuplePattern(d[2]) %}
+    | "[" _ pattern_list _ %consOp _ pattern _ "]" {% (d) => {
+        const heads = d[2];
+        const tail = d[6];
+        let current = tail;
+        for (let i = heads.length - 1; i >= 0; i--) {
+            current = new ConsPattern(heads[i], current);
+        }
+        return current;
+    } %}
+    | "[" _ pattern_list:? _ "]"  {% (d) => new ListPattern(d[2] ? d[2] : []) %}
+
+infix_pattern -> primary_pattern _ any_atom _ pattern {% (d) => new FunctorPattern(d[2], [d[0], d[4]]) %}
+
+variable -> %variable {% (d) => new SymbolPrimitive(d[0].value) %}
+
+strict_atom -> %atom {% (d) => new SymbolPrimitive(d[0].value) %}
+             | %primitiveOperator {% (d) => new SymbolPrimitive(d[0].value) %}
+
+any_atom -> strict_atom {% id %}
+          | (%op | %comparisonOp) {% (d) => new SymbolPrimitive(d[0][0].value) %}
+
+arithmetic_literal -> 
+    strict_atom {% id %}
+    | %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
+    | %string {% (d) => new StringPrimitive(d[0].value) %}
+
+structural_literal -> 
+    any_atom {% id %}
+    | %number {% (d) => new NumberPrimitive(Number(d[0].value)) %}
+    | %string {% (d) => new StringPrimitive(d[0].value) %}
+
+comparison_op ->
+    "=:=" {% d => "Equal" %}
+    | "=\\=" {% d => "NotEqual" %}
+    | "==" {% d => "Same" %}
+    | "\\==" {% d => "NotSame" %}
+    | "\\=" {% d => "NotSame" %}
+    | "@<" {% d => "LessThan" %}
+    | "@=<" {% d => "LessOrEqualThan" %}
+    | "@>" {% d => "GreaterThan" %}
+    | "@>=" {% d => "GreaterOrEqualThan" %}
+    | "<" {% d => "LessThan" %}
+    | "=<" {% d => "LessOrEqualThan" %}
+    | ">" {% d => "GreaterThan" %}
+    | ">=" {% d => "GreaterOrEqualThan" %}
+    | "=@=" {% d => "Same" %}
+    | "\\=@=" {% d => "NotSame" %}
+
+_ -> %WS:*
+__ -> %WS:?