yukigo-prolog-parser 0.1.3 → 0.2.2

package/dist/std.js

@@ -1,133 +1,133 @@
-export const stdCode = `
-% between(+Low, +High, ?Value)
-% True if Low =< Value =< High (assuming integers)
-between(Low, High, Low) :- Low =< High.
-between(Low, High, Value) :-
-    Low < High,
-    NextLow is Low + 1,
-    between(NextLow, High, Value).
-
-% union(+List1, +List2, -Union)
-% Union of two lists without duplicates (order not preserved)
-union([], L, L).
-union([H|T], L2, Union) :-
-    (   member(H, L2)
-    ->  union(T, L2, Union)
-    ;   Union = [H|Rest],
-        union(T, L2, Rest)
-    ).
-
-% intersection(+List1, +List2, -Intersection)
-intersection([], _, []).
-intersection([H|T], L2, [H|Rest]) :-
-    member(H, L2),
-    !,
-    intersection(T, L2, Rest).
-intersection([_|T], L2, Rest) :-
-    intersection(T, L2, Rest).
-
-% max_member(-Max, +List)
-max_member(Max, [Max]) :- !.
-max_member(Max, [H|T]) :-
-    max_member(M, T),
-    (   H > M
-    ->  Max = H
-    ;   Max = M
-    ).
-
-% min_member(-Min, +List)
-min_member(Min, [Min]) :- !.
-min_member(Min, [H|T]) :-
-    min_member(M, T),
-    (   H < M
-    ->  Min = H
-    ;   Min = M
-    ).
-
-% sumlist(+List, -Sum)
-sumlist([], 0).
-sumlist([H|T], Sum) :-
-    sumlist(T, RestSum),
-    Sum is H + RestSum.
-
-% length(?List, ?Length)
-length([], 0).
-length([_|Tail], N) :-
-    length(Tail, M),
-    N is M + 1.
-
-% flatten(+NestedList, -FlatList)
-flatten([], []).
-flatten([H|T], Flat) :-
-    !,
-    flatten(H, FlatH),
-    flatten(T, FlatT),
-    append(FlatH, FlatT, Flat).
-flatten(X, [X]).
-
-% reverse(+List, -Reversed)
-reverse(List, Reversed) :-
-    reverse_acc(List, [], Reversed).
-
-reverse_acc([], Acc, Acc).
-reverse_acc([H|T], Acc, Reversed) :-
-    reverse_acc(T, [H|Acc], Reversed).
-
-% list_to_set(+List, -Set)
-% Removes duplicates, keeps first occurrence
-list_to_set([], []).
-list_to_set([H|T], [H|Rest]) :-
-    exclude(==(H), T, T1),
-    list_to_set(T1, Rest).
-
-==(H, T) :-
-    H == T.
-
-% nth0(?Index, ?List, ?Elem)
-% Index starts at 0
-nth0(0, [H|_], H).
-nth0(N, [_|T], Elem) :-
-    N > 0,
-    N1 is N - 1,
-    nth0(N1, T, Elem).
-
-% nth1(?Index, ?List, ?Elem)
-% Index starts at 1
-nth1(1, [H|_], H).
-nth1(N, [_|T], Elem) :-
-    N > 1,
-    N1 is N - 1,
-    nth1(N1, T, Elem).
-
-% append/3 (needed for flatten and union)
-append([], L, L).
-append([H|T], L, [H|R]) :-
-    append(T, L, R).
-
-% member/2 (needed for many predicates)
-member(H, [H|_]).
-member(H, [_|T]) :-
-    member(H, T).
-
-% exclude(+Pred, +List, -Filtered)
-% Removes elements satisfying Pred
-exclude(_, [], []).
-exclude(Pred, [H|T], Rest) :-
-    (   call(Pred, H)
-    ->  exclude(Pred, T, Rest)
-    ;   Rest = [H|Rest2],
-        exclude(Pred, T, Rest2)
-    ).
-
-% Arithmetic predicates
-abs(X, Y) :- Y is abs(X).
-round(X, Y) :- Y is round(X).
-sqrt(X, Y) :- Y is sqrt(X).
-
-
-max_list([X], X).
-max_list([H|T], Max) :-
-    max_list(T, MaxTail),
-    Max is max(H, MaxTail).
+export const stdCode = `
+% between(+Low, +High, ?Value)
+% True if Low =< Value =< High (assuming integers)
+between(Low, High, Low) :- Low =< High.
+between(Low, High, Value) :-
+    Low < High,
+    NextLow is Low + 1,
+    between(NextLow, High, Value).
+
+% union(+List1, +List2, -Union)
+% Union of two lists without duplicates (order not preserved)
+union([], L, L).
+union([H|T], L2, Union) :-
+    (   member(H, L2)
+    ->  union(T, L2, Union)
+    ;   Union = [H|Rest],
+        union(T, L2, Rest)
+    ).
+
+% intersection(+List1, +List2, -Intersection)
+intersection([], _, []).
+intersection([H|T], L2, [H|Rest]) :-
+    member(H, L2),
+    !,
+    intersection(T, L2, Rest).
+intersection([_|T], L2, Rest) :-
+    intersection(T, L2, Rest).
+
+% max_member(-Max, +List)
+max_member(Max, [Max]) :- !.
+max_member(Max, [H|T]) :-
+    max_member(M, T),
+    (   H > M
+    ->  Max = H
+    ;   Max = M
+    ).
+
+% min_member(-Min, +List)
+min_member(Min, [Min]) :- !.
+min_member(Min, [H|T]) :-
+    min_member(M, T),
+    (   H < M
+    ->  Min = H
+    ;   Min = M
+    ).
+
+% sumlist(+List, -Sum)
+sumlist([], 0).
+sumlist([H|T], Sum) :-
+    sumlist(T, RestSum),
+    Sum is H + RestSum.
+
+% length(?List, ?Length)
+length([], 0).
+length([_|Tail], N) :-
+    length(Tail, M),
+    N is M + 1.
+
+% flatten(+NestedList, -FlatList)
+flatten([], []).
+flatten([H|T], Flat) :-
+    !,
+    flatten(H, FlatH),
+    flatten(T, FlatT),
+    append(FlatH, FlatT, Flat).
+flatten(X, [X]).
+
+% reverse(+List, -Reversed)
+reverse(List, Reversed) :-
+    reverse_acc(List, [], Reversed).
+
+reverse_acc([], Acc, Acc).
+reverse_acc([H|T], Acc, Reversed) :-
+    reverse_acc(T, [H|Acc], Reversed).
+
+% list_to_set(+List, -Set)
+% Removes duplicates, keeps first occurrence
+list_to_set([], []).
+list_to_set([H|T], [H|Rest]) :-
+    exclude(==(H), T, T1),
+    list_to_set(T1, Rest).
+
+==(H, T) :-
+    H == T.
+
+% nth0(?Index, ?List, ?Elem)
+% Index starts at 0
+nth0(0, [H|_], H).
+nth0(N, [_|T], Elem) :-
+    N > 0,
+    N1 is N - 1,
+    nth0(N1, T, Elem).
+
+% nth1(?Index, ?List, ?Elem)
+% Index starts at 1
+nth1(1, [H|_], H).
+nth1(N, [_|T], Elem) :-
+    N > 1,
+    N1 is N - 1,
+    nth1(N1, T, Elem).
+
+% append/3 (needed for flatten and union)
+append([], L, L).
+append([H|T], L, [H|R]) :-
+    append(T, L, R).
+
+% member/2 (needed for many predicates)
+member(H, [H|_]).
+member(H, [_|T]) :-
+    member(H, T).
+
+% exclude(+Pred, +List, -Filtered)
+% Removes elements satisfying Pred
+exclude(_, [], []).
+exclude(Pred, [H|T], Rest) :-
+    (   call(Pred, H)
+    ->  exclude(Pred, T, Rest)
+    ;   Rest = [H|Rest2],
+        exclude(Pred, T, Rest2)
+    ).
+
+% Arithmetic predicates
+abs(X, Y) :- Y is abs(X).
+round(X, Y) :- Y is round(X).
+sqrt(X, Y) :- Y is sqrt(X).
+
+
+max_list([X], X).
+max_list([H|T], Max) :-
+    max_list(T, MaxTail),
+    Max is max(H, MaxTail).
 `;
 //# sourceMappingURL=std.js.map

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "yukigo-prolog-parser",
-  "version": "0.1.3",
+  "version": "0.2.2",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "nearleyc ./src/parser/grammar.ne -o ./src/parser/grammar.ts && tsc",
+    "build": "nearleyc ./src/parser/grammar.ne -o ./src/parser/grammar.cjs && tsc",
     "test": "mocha --import=tsx"
   },
   "keywords": [],
@@ -17,23 +17,16 @@
     "moo-ignore": "^2.5.3",
     "nearley": "^2.20.1"
   },
+  "devDependencies": {
+    "@types/moo": "^0.5.10"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
-  "devDependencies": {
-    "@types/chai": "^5.2.2",
-    "@types/mocha": "^10.0.10",
-    "@types/moo": "^0.5.10",
-    "@types/node": "^24.10.0",
-    "chai": "^6.2.0",
-    "mocha": "^11.7.1",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.2"
-  },
   "peerDependencies": {
-    "yukigo-ast": "^0.2.0"
+    "yukigo-ast": "^0.3.0"
   }
 }

package/src/index.ts

@@ -1,82 +1,93 @@
-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];
-}
+import { AST, Expression, Rule, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./parser/grammar.cjs";
+import { Token } from "moo";
+import { stdCode } from "./std.js";
+
+interface NearleyError {
+  token?: any;
+  offset?: number;
+  [key: string]: any;
+}
+
+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 as any)
+    );
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (e: unknown) {
+      const error = e as NearleyError; // Assert the shape
+      if (error.token) {
+        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];
+}