yukigo-prolog-parser 0.1.0

package/src/parser/grammar.ts

@@ -0,0 +1,219 @@
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+// Bypasses TS6133. Allow declared but unused functions.
+// @ts-ignore
+function id(d: any[]): any { return d[0]; }
+declare var period: 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 op: any;
+declare var comparisonOp: any;
+declare var number: any;
+declare var string: any;
+declare var WS: any;
+
+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);
+
+
+interface NearleyToken {
+  value: any;
+  [key: string]: any;
+};
+
+interface NearleyLexer {
+  reset: (chunk: string, info: any) => void;
+  next: () => NearleyToken | undefined;
+  save: () => any;
+  formatError: (token: never) => string;
+  has: (tokenType: string) => boolean;
+};
+
+interface NearleyRule {
+  name: string;
+  symbols: NearleySymbol[];
+  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
+};
+
+type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
+
+interface Grammar {
+  Lexer: NearleyLexer | undefined;
+  ParserRules: NearleyRule[];
+  ParserStart: string;
+};
+
+const grammar: Grammar = {
+  Lexer: PrologLexer,
+  ParserRules: [
+    {"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": "clause$subexpression$1", "symbols": ["fact"]},
+    {"name": "clause$subexpression$1", "symbols": ["rule"]},
+    {"name": "clause$subexpression$1", "symbols": ["query"]},
+    {"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": "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)]},
+    {"name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [(PrologLexer.has("semicolon") ? {type: "semicolon"} : semicolon)]},
+    {"name": "body$ebnf$1$subexpression$1", "symbols": ["_", "body$ebnf$1$subexpression$1$subexpression$1", "_", "expression"]},
+    {"name": "body$ebnf$1", "symbols": ["body$ebnf$1", "body$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "body", "symbols": ["expression", "body$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
+    {"name": "expression$subexpression$1", "symbols": ["conditional"]},
+    {"name": "expression$subexpression$1", "symbols": ["forall"]},
+    {"name": "expression$subexpression$1", "symbols": ["findall"]},
+    {"name": "expression$subexpression$1", "symbols": ["unification"]},
+    {"name": "expression$subexpression$1", "symbols": ["assignment"]},
+    {"name": "expression$subexpression$1", "symbols": ["comparison"]},
+    {"name": "expression$subexpression$1", "symbols": ["not"]},
+    {"name": "expression$subexpression$1", "symbols": ["exist"]},
+    {"name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => d[0][0]},
+    {"name": "expression", "symbols": [{"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => 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": "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)
+        } },
+    {"name": "exist$ebnf$1", "symbols": ["arguments"], "postprocess": id},
+    {"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;
+            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": "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},
+    {"name": "multiplication", "symbols": ["primary", "_", {"literal":"*"}, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4])},
+    {"name": "multiplication", "symbols": ["primary", "_", {"literal":"/"}, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4])},
+    {"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": ["primitiveOperation"], "postprocess": id},
+    {"name": "primary", "symbols": ["cons_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": "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": "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"]},
+    {"name": "primary_list$ebnf$1", "symbols": ["primary_list$ebnf$1", "primary_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "primary_list", "symbols": ["addition", "primary_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
+    {"name": "arguments", "symbols": [(PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "pattern_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess": (d) => d[2]},
+    {"name": "pattern_list$ebnf$1", "symbols": []},
+    {"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": "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": "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)},
+    {"name": "arithmetic_literal", "symbols": ["strict_atom"], "postprocess": id},
+    {"name": "arithmetic_literal", "symbols": [(PrologLexer.has("number") ? {type: "number"} : number)], "postprocess": (d) => new NumberPrimitive(Number(d[0].value))},
+    {"name": "arithmetic_literal", "symbols": [(PrologLexer.has("string") ? {type: "string"} : string)], "postprocess": (d) => new StringPrimitive(d[0].value)},
+    {"name": "structural_literal", "symbols": ["any_atom"], "postprocess": id},
+    {"name": "structural_literal", "symbols": [(PrologLexer.has("number") ? {type: "number"} : number)], "postprocess": (d) => new NumberPrimitive(Number(d[0].value))},
+    {"name": "structural_literal", "symbols": [(PrologLexer.has("string") ? {type: "string"} : string)], "postprocess": (d) => new StringPrimitive(d[0].value)},
+    {"name": "comparison_op", "symbols": [{"literal":"=:="}], "postprocess": d => "Equal"},
+    {"name": "comparison_op", "symbols": [{"literal":"=\\="}], "postprocess": d => "NotEqual"},
+    {"name": "comparison_op", "symbols": [{"literal":"=="}], "postprocess": d => "Same"},
+    {"name": "comparison_op", "symbols": [{"literal":"\\=="}], "postprocess": d => "NotSame"},
+    {"name": "comparison_op", "symbols": [{"literal":"\\="}], "postprocess": d => "NotSame"},
+    {"name": "comparison_op", "symbols": [{"literal":"@<"}], "postprocess": d => "LessThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"@=<"}], "postprocess": d => "LessOrEqualThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"@>"}], "postprocess": d => "GreaterThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"@>="}], "postprocess": d => "GreaterOrEqualThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"<"}], "postprocess": d => "LessThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"=<"}], "postprocess": d => "LessOrEqualThan"},
+    {"name": "comparison_op", "symbols": [{"literal":">"}], "postprocess": d => "GreaterThan"},
+    {"name": "comparison_op", "symbols": [{"literal":">="}], "postprocess": d => "GreaterOrEqualThan"},
+    {"name": "comparison_op", "symbols": [{"literal":"=@="}], "postprocess": d => "Same"},
+    {"name": "comparison_op", "symbols": [{"literal":"\\=@="}], "postprocess": d => "NotSame"},
+    {"name": "_$ebnf$1", "symbols": []},
+    {"name": "_$ebnf$1", "symbols": ["_$ebnf$1", (PrologLexer.has("WS") ? {type: "WS"} : WS)], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "_", "symbols": ["_$ebnf$1"]},
+    {"name": "__$ebnf$1", "symbols": [(PrologLexer.has("WS") ? {type: "WS"} : WS)], "postprocess": id},
+    {"name": "__$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "__", "symbols": ["__$ebnf$1"]}
+  ],
+  ParserStart: "program",
+};
+
+export default grammar;

package/src/parser/lexer.ts

@@ -0,0 +1,39 @@
+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"]);

package/src/parser/parser.ts

@@ -0,0 +1,35 @@
+import { AST, YukigoParser } from "yukigo-ast";
+import nearley from "nearley";
+import grammar from "./grammar.js";
+
+export class YukigoPrologParser implements YukigoParser {
+  public errors: string[] = [];
+  public parse(code: string): AST {
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (error) {
+      console.log(error)
+      if ("token" in error) throw Error(error);
+      const token = error.token;
+      const message = `Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`;
+      this.errors.push(message);
+      throw Error(message);
+    }
+    if (parser.results.length > 1) {
+      this.errors.push(
+        `Too much ambiguity. ${parser.results.length} ASTs. Output not generated.`
+      );
+      throw Error(
+        `Too much ambiguity. ${parser.results.length} ASTs. Output not generated.`
+      );
+    }
+    if (parser.results.length == 0) {
+      this.errors.push("Parser did not generate an AST.");
+      throw Error("Parser did not generate an AST.");
+    }
+
+    return parser.results[0];
+  }
+}

package/src/std.pl

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