yukigo-prolog-parser 0.1.0 → 0.1.2

package/src/parser/grammar.ts

@@ -4,31 +4,32 @@
 // @ts-ignore
 function id(d: any[]): any { return d[0]; }
 declare var period: any;
+declare var testKeyword: any;
+declare var lparen: any;
+declare var rparen: any;
+declare var comma: any;
 declare var colonDash: any;
 declare var queryOp: any;
-declare var comma: any;
 declare var semicolon: any;
 declare var forallRule: any;
 declare var findallRule: any;
-declare var notOperator: any;
-declare var lparen: any;
-declare var rparen: any;
 declare var consOp: any;
 declare var wildcard: any;
 declare var variable: any;
 declare var atom: any;
+declare var primitiveOperator: any;
 declare var op: any;
 declare var comparisonOp: any;
 declare var number: any;
 declare var string: any;
 declare var WS: any;
-
-import { 
+ import { 
     NumberPrimitive, 
     StringPrimitive, 
     Rule, 
     Fact, 
     Query,
+    ListPrimitive,
     ConsExpression,
     ArithmeticBinaryOperation,
     ArithmeticUnaryOperation,
@@ -37,6 +38,8 @@ import {
     Not, 
     Findall, 
     Sequence,
+    UnguardedBody,
+    Equation,
     If,
     Call,
     Forall, 
@@ -47,14 +50,22 @@ import {
     FunctorPattern, 
     ConsPattern, 
     ListPattern, 
+    LogicConstraint,
     LiteralPattern,
     WildcardPattern,
-    TuplePattern
+    TuplePattern,
+    Test,
+    Assert,
+    Truth
  } from "yukigo-ast"
 
 import { PrologLexer } from "./lexer.js"
 
-const asSequence = (d) => d.length === 1 ? d[0] : new Sequence(d);
+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]);
+};
 
 
 interface NearleyToken {
@@ -90,17 +101,23 @@ const grammar: Grammar = {
     {"name": "program$ebnf$1", "symbols": []},
     {"name": "program$ebnf$1$subexpression$1", "symbols": ["clause", "_"]},
     {"name": "program$ebnf$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "program", "symbols": ["program$ebnf$1"], "postprocess": (d) => d[0].map(x => x[0]).filter(x => x !== null).flat(Infinity)},
+    {"name": "program", "symbols": ["_", "program$ebnf$1"], "postprocess": (d) => d[1].map(x => x[0]).filter(x => x !== null).flat(Infinity)},
     {"name": "clause$subexpression$1", "symbols": ["fact"]},
     {"name": "clause$subexpression$1", "symbols": ["rule"]},
     {"name": "clause$subexpression$1", "symbols": ["query"]},
+    {"name": "clause$subexpression$1", "symbols": ["test_rule"]},
     {"name": "clause", "symbols": ["clause$subexpression$1"], "postprocess": (d) => d[0][0]},
     {"name": "fact$ebnf$1", "symbols": ["arguments"], "postprocess": id},
     {"name": "fact$ebnf$1", "symbols": [], "postprocess": () => null},
     {"name": "fact", "symbols": ["any_atom", "fact$ebnf$1", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Fact(d[0], d[1] ?? [])},
-    {"name": "rule$ebnf$1", "symbols": ["arguments"], "postprocess": id},
-    {"name": "rule$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "rule", "symbols": ["any_atom", "rule$ebnf$1", "_", (PrologLexer.has("colonDash") ? {type: "colonDash"} : colonDash), "_", "body", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Rule(d[0], d[1] ?? [], d[5])},
+    {"name": "rule", "symbols": ["any_atom", "equation", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Rule(d[0], [d[1]])},
+    {"name": "test_rule$ebnf$1", "symbols": ["test_args"], "postprocess": id},
+    {"name": "test_rule$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "test_rule", "symbols": [(PrologLexer.has("testKeyword") ? {type: "testKeyword"} : testKeyword), (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "structural_literal", "test_rule$ebnf$1", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen), "equation", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Test(d[3], d[7].body.sequence, d[4] ? [d[4]] : [])},
+    {"name": "test_args", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern"], "postprocess": (d) => d[3]},
+    {"name": "equation$ebnf$1", "symbols": ["arguments"], "postprocess": id},
+    {"name": "equation$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "equation", "symbols": ["equation$ebnf$1", "_", (PrologLexer.has("colonDash") ? {type: "colonDash"} : colonDash), "_", "body"], "postprocess": (d) => new Equation(d[0] || [], new UnguardedBody(new Sequence(d[4])))},
     {"name": "query", "symbols": [(PrologLexer.has("queryOp") ? {type: "queryOp"} : queryOp), "_", "body", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Query(d[2])},
     {"name": "body$ebnf$1", "symbols": []},
     {"name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [(PrologLexer.has("comma") ? {type: "comma"} : comma)]},
@@ -116,19 +133,20 @@ const grammar: Grammar = {
     {"name": "expression$subexpression$1", "symbols": ["comparison"]},
     {"name": "expression$subexpression$1", "symbols": ["not"]},
     {"name": "expression$subexpression$1", "symbols": ["exist"]},
+    {"name": "expression$subexpression$1", "symbols": ["assertion"]},
     {"name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => d[0][0]},
-    {"name": "expression", "symbols": [{"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => d[2]},
+    {"name": "expression", "symbols": [{"literal":"("}, "_", "body", "_", {"literal":")"}], "postprocess": (d) => new Sequence(d[2])},
     {"name": "conditional", "symbols": [{"literal":"("}, "_", "body", "_", {"literal":"->"}, "_", "body", "_", (PrologLexer.has("semicolon") ? {type: "semicolon"} : semicolon), "_", "body", "_", {"literal":")"}], "postprocess":  (d) => 
         new If(
             asSequence(d[2]),  
             asSequence(d[6]),   
             asSequence(d[10])
-        ) 
+        )
         },
     {"name": "forall", "symbols": [(PrologLexer.has("forallRule") ? {type: "forallRule"} : forallRule), {"literal":"("}, "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", {"literal":")"}], "postprocess": (d) => new Forall(d[3], d[7])},
-    {"name": "findall", "symbols": [(PrologLexer.has("findallRule") ? {type: "findallRule"} : findallRule), {"literal":"("}, "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", {"literal":")"}], "postprocess": (d) => new Findall(d[3], d[7], d[11])},
-    {"name": "not", "symbols": [(PrologLexer.has("notOperator") ? {type: "notOperator"} : notOperator), "_", "expression"], "postprocess": (d) => new Not([d[2]])},
-    {"name": "not", "symbols": [(PrologLexer.has("notOperator") ? {type: "notOperator"} : notOperator), "_", {"literal":"("}, "_", {"literal":"("}, "_", "body", "_", {"literal":")"}, "_", {"literal":")"}], "postprocess": (d) => new Not([asSequence(d[6])])},
+    {"name": "findall", "symbols": [(PrologLexer.has("findallRule") ? {type: "findallRule"} : findallRule), {"literal":"("}, "_", "pattern", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern", "_", {"literal":")"}], "postprocess": (d) => new Findall(d[3], d[7], d[11])},
+    {"name": "not", "symbols": [{"literal":"not"}, {"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => new Not(asSequence(d[3]))},
+    {"name": "not", "symbols": [{"literal":"\\+"}, "_", "expression"], "postprocess": (d) => new Not(d[2])},
     {"name": "exist", "symbols": [{"literal":"call"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "pattern_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => {
             const [callee, ...rest] = d[3]
             return new Call(callee.name, rest)
@@ -137,13 +155,20 @@ const grammar: Grammar = {
     {"name": "exist$ebnf$1", "symbols": [], "postprocess": () => null},
     {"name": "exist", "symbols": ["any_atom", "exist$ebnf$1"], "postprocess":  (d, l, reject) => {
             const val = d[0].value; 
-            if (val === "not" || val === "\\+") return reject;
+            if (["not", "\\+", "call", "assertion"].includes(val)) return reject;
             return new Exist(d[0], d[1] ?? []) 
         } },
     {"name": "exist", "symbols": ["variable"], "postprocess": (d) => new Exist(d[0], [])},
-    {"name": "assignment", "symbols": ["addition", "_", {"literal":"is"}, "_", "addition"], "postprocess": (d) => new AssignOperation("Assign", d[0], d[4])},
-    {"name": "unification", "symbols": ["addition", "_", {"literal":"="}, "_", "addition"], "postprocess": (d) => new UnifyOperation("Unify", d[0], d[4])},
-    {"name": "comparison", "symbols": ["addition", "_", "comparison_op", "_", "addition"], "postprocess": (d) => new ComparisonOperation(d[2], d[0], d[4])},
+    {"name": "assertion", "symbols": [{"literal":"assertion"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "expression", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => 
+        new Assert(null, new Truth(asSequence(d[3]))) 
+        },
+    {"name": "assignment", "symbols": ["addition", "_", {"literal":"is"}, "_", "addition"], "postprocess":  (d) => 
+        new LogicConstraint(new AssignOperation("Assign", d[0], d[4])) 
+            },
+    {"name": "unification", "symbols": ["addition", "_", {"literal":"="}, "_", "addition"], "postprocess": (d) => new LogicConstraint(new UnifyOperation("Unify", d[0], d[4]))},
+    {"name": "comparison", "symbols": ["addition", "_", "comparison_op", "_", "addition"], "postprocess":  (d) => 
+        new LogicConstraint(new ComparisonOperation(d[2], d[0], d[4])) 
+            },
     {"name": "addition", "symbols": ["multiplication", "_", {"literal":"+"}, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4])},
     {"name": "addition", "symbols": ["multiplication", "_", {"literal":"-"}, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4])},
     {"name": "addition", "symbols": ["multiplication"], "postprocess": id},
@@ -152,14 +177,32 @@ const grammar: Grammar = {
     {"name": "multiplication", "symbols": ["primary"], "postprocess": id},
     {"name": "primary", "symbols": ["arithmetic_literal"], "postprocess": id},
     {"name": "primary", "symbols": ["variable"], "postprocess": id},
-    {"name": "primary", "symbols": ["strict_atom", "arguments"], "postprocess": d => new Exist(d[0], d[1] ?? [])},
+    {"name": "primary", "symbols": [{"literal":"-"}, "_", "primary"], "postprocess": (d) => new ArithmeticUnaryOperation("Negation", d[2])},
+    {"name": "primary", "symbols": ["strict_atom", "arguments"], "postprocess":  (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] ?? [])
+        } },
     {"name": "primary", "symbols": ["primitiveOperation"], "postprocess": id},
     {"name": "primary", "symbols": ["cons_expr"], "postprocess": id},
+    {"name": "primary", "symbols": ["list_expr"], "postprocess": id},
     {"name": "primary", "symbols": [{"literal":"("}, "_", "addition", "_", {"literal":")"}], "postprocess": d => d[2]},
-    {"name": "cons_expr", "symbols": [{"literal":"["}, "_", "primary_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "expression", "_", {"literal":"]"}], "postprocess": (d) => new ConsExpression(d[2], d[6])},
+    {"name": "list_expr$ebnf$1", "symbols": ["primary_list"], "postprocess": id},
+    {"name": "list_expr$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "list_expr", "symbols": [{"literal":"["}, "_", "list_expr$ebnf$1", "_", {"literal":"]"}], "postprocess": (d) => new ListPrimitive(d[2] || [])},
+    {"name": "cons_expr", "symbols": [{"literal":"["}, "_", "primary_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "addition", "_", {"literal":"]"}], "postprocess":  (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;
+        } },
     {"name": "primitiveOperation", "symbols": [{"literal":"round"}, "__", "addition"], "postprocess": d => new ArithmeticUnaryOperation("Round", d[2])},
     {"name": "primitiveOperation", "symbols": [{"literal":"abs"}, "__", "addition"], "postprocess": d => new ArithmeticUnaryOperation("Absolute", d[2])},
     {"name": "primitiveOperation", "symbols": [{"literal":"sqrt"}, "__", "addition"], "postprocess": d => new ArithmeticUnaryOperation("Sqrt", d[2])},
+    {"name": "primitiveOperation", "symbols": [{"literal":"max"}, {"literal":"("}, "_", "addition", "_", {"literal":","}, "_", "addition", "_", {"literal":")"}], "postprocess": d => new ArithmeticBinaryOperation("Max", d[3], d[7])},
     {"name": "primitiveArguments", "symbols": [(PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "primary_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess": (d) => d[2]},
     {"name": "primary_list$ebnf$1", "symbols": []},
     {"name": "primary_list$ebnf$1$subexpression$1", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "addition"]},
@@ -170,18 +213,30 @@ const grammar: Grammar = {
     {"name": "pattern_list$ebnf$1$subexpression$1", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern"]},
     {"name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
     {"name": "pattern_list", "symbols": ["pattern", "pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
-    {"name": "pattern", "symbols": ["variable"], "postprocess": (d) => new VariablePattern(d[0])},
-    {"name": "pattern", "symbols": ["structural_literal"], "postprocess": (d) => new LiteralPattern(d[0])},
-    {"name": "pattern", "symbols": [(PrologLexer.has("wildcard") ? {type: "wildcard"} : wildcard)], "postprocess": (d) => new WildcardPattern()},
-    {"name": "pattern", "symbols": ["any_atom", "arguments"], "postprocess": (d) => new FunctorPattern(d[0], d[1])},
-    {"name": "pattern", "symbols": [{"literal":"("}, "_", "pattern_list", "_", {"literal":")"}], "postprocess": (d) => new TuplePattern(d[2])},
-    {"name": "pattern", "symbols": [{"literal":"["}, "_", "pattern_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "pattern", "_", {"literal":"]"}], "postprocess": (d) => new ConsPattern(d[2].length > 1 ? new ListPattern(d[2]) : d[2][0], new VariablePattern(d[6]))},
-    {"name": "pattern$ebnf$1", "symbols": ["pattern_list"], "postprocess": id},
-    {"name": "pattern$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "pattern", "symbols": [{"literal":"["}, "_", "pattern$ebnf$1", "_", {"literal":"]"}], "postprocess": (d) => new ListPattern(d[2] ? d[2] : [])},
+    {"name": "pattern", "symbols": ["infix_pattern"], "postprocess": id},
+    {"name": "pattern", "symbols": ["primary_pattern"], "postprocess": id},
+    {"name": "primary_pattern", "symbols": ["variable"], "postprocess": (d) => new VariablePattern(d[0])},
+    {"name": "primary_pattern", "symbols": ["structural_literal"], "postprocess": (d) => new LiteralPattern(d[0])},
+    {"name": "primary_pattern", "symbols": [(PrologLexer.has("wildcard") ? {type: "wildcard"} : wildcard)], "postprocess": (d) => new WildcardPattern()},
+    {"name": "primary_pattern", "symbols": ["any_atom", "arguments"], "postprocess": (d) => new FunctorPattern(d[0], d[1])},
+    {"name": "primary_pattern", "symbols": [{"literal":"("}, "_", "pattern_list", "_", {"literal":")"}], "postprocess": (d) => new TuplePattern(d[2])},
+    {"name": "primary_pattern", "symbols": [{"literal":"["}, "_", "pattern_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "pattern", "_", {"literal":"]"}], "postprocess":  (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;
+        } },
+    {"name": "primary_pattern$ebnf$1", "symbols": ["pattern_list"], "postprocess": id},
+    {"name": "primary_pattern$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "primary_pattern", "symbols": [{"literal":"["}, "_", "primary_pattern$ebnf$1", "_", {"literal":"]"}], "postprocess": (d) => new ListPattern(d[2] ? d[2] : [])},
+    {"name": "infix_pattern", "symbols": ["primary_pattern", "_", "any_atom", "_", "pattern"], "postprocess": (d) => new FunctorPattern(d[2], [d[0], d[4]])},
     {"name": "variable", "symbols": [(PrologLexer.has("variable") ? {type: "variable"} : variable)], "postprocess": (d) => new SymbolPrimitive(d[0].value)},
     {"name": "strict_atom", "symbols": [(PrologLexer.has("atom") ? {type: "atom"} : atom)], "postprocess": (d) => new SymbolPrimitive(d[0].value)},
-    {"name": "any_atom$subexpression$1", "symbols": [(PrologLexer.has("atom") ? {type: "atom"} : atom)]},
+    {"name": "strict_atom", "symbols": [(PrologLexer.has("primitiveOperator") ? {type: "primitiveOperator"} : primitiveOperator)], "postprocess": (d) => new SymbolPrimitive(d[0].value)},
+    {"name": "any_atom", "symbols": ["strict_atom"], "postprocess": id},
     {"name": "any_atom$subexpression$1", "symbols": [(PrologLexer.has("op") ? {type: "op"} : op)]},
     {"name": "any_atom$subexpression$1", "symbols": [(PrologLexer.has("comparisonOp") ? {type: "comparisonOp"} : comparisonOp)]},
     {"name": "any_atom", "symbols": ["any_atom$subexpression$1"], "postprocess": (d) => new SymbolPrimitive(d[0][0].value)},

package/src/parser/lexer.ts

@@ -1,39 +1,40 @@
-import { makeLexer } from "moo-ignore";
-import moo from "moo";
-export const PrologLexerConfig = {
-  WS: /[ \t]+/,
-  wildcard: "_",
-  notOperator: { match: ["\\+", "not"] },
-  forallRule: "forall",
-  findallRule: "findall",
-  comment: /%.*|\/\*[\s\S]*?\*\//,
-  number:
-    /-?\b(?:[0-9]+(?:\.[0-9]+(?:e[+-]?[0-9]+)?)?|0o[0-7]+|0x[0-9a-fA-F]+|0b[01]+)\b/,
-  string: /(?:'(?:[^']|'')*')/,
-  backtick: "`",
-  lparen: "(",
-  rparen: ")",
-  lbracket: "{",
-  rbracket: "}",
-  lsquare: "[",
-  rsquare: "]",
-  comma: ",",
-  arrow: "->",
-  period: ".",
-  semicolon: ";",
-  colonDash: ":-",
-  consOp: "|",
-  queryOp: "?-",
-  comparisonOp: /@<|@=<|@>=|@>|<|=<|>=|>|=@=|\\=@=|=:=|=\\=|==|\\==|\\=|=/,
-  op: /\+|-|\*|\/|\/\/|~|\^|\?|\$|''|\.\./,
-  variable: /[A-Z][a-zA-Z0-9_]*/,
-  atom: {
-    match: /[a-z!][a-zA-Z0-9_]*/,
-    type: moo.keywords({
-      primitiveOperator: ["round", "abs", "sqrt", "call"],
-    }),
-  },
-  NL: { match: /\r?\n/, lineBreaks: true },
-};
-
-export const PrologLexer = makeLexer(PrologLexerConfig, ["comment", "NL"]);
+import { makeLexer } from "moo-ignore";
+import moo from "moo";
+export const PrologLexerConfig = {
+  WS: /[ \t]+/,
+  wildcard: "_",
+  notOperator: { match: ["\\+", "not"] },
+  forallRule: "forall",
+  findallRule: "findall",
+  comment: /%.*|\/\*[\s\S]*?\*\//,
+  number:
+    /\b(?:[0-9]+(?:\.[0-9]+(?:e[+-]?[0-9]+)?)?|0o[0-7]+|0x[0-9a-fA-F]+|0b[01]+)\b/,
+  string: /(?:'(?:[^']|'')*'|"(?:[^"]|"")*")/,
+  backtick: "`",
+  lparen: "(",
+  rparen: ")",
+  lbracket: "{",
+  rbracket: "}",
+  lsquare: "[",
+  rsquare: "]",
+  comma: ",",
+  arrow: "->",
+  period: ".",
+  semicolon: ";",
+  colonDash: ":-",
+  consOp: "|",
+  queryOp: "?-",
+  comparisonOp: /@<|@=<|@>=|@>|<|=<|>=|>|=@=|\\=@=|=:=|=\\=|==|\\==|\\=|=/,
+  op: /\+|-|\*|\/|\/\/|~|\^|\?|\$|''|\.\./,
+  variable: /[A-Z][a-zA-Z0-9_\u00C0-\u00FF]*/,
+  atom: {
+    match: /[a-z!][a-zA-Z0-9_\u00C0-\u00FF]*/,
+    type: moo.keywords({
+      primitiveOperator: ["round", "abs", "sqrt", "call", "max", "assertion"],
+      testKeyword: ["test"],
+    }),
+  },
+  NL: { match: /\r?\n/, lineBreaks: true },
+};
+
+export const PrologLexer = makeLexer(PrologLexerConfig, ["comment", "NL"]);

package/src/{std.pl → std.ts}

@@ -1,119 +1,132 @@
-% 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)
-    ).
+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).
+`