#Prolog in MoonBit

#Features

• Terms: atoms, variables, integers, floats, strings, lists ([a, b|T]), and compound terms, with a parser for the standard operator set (:-, ;, ,, \+, =, \=, ==, \==, is, comparisons, arithmetic operators) and round-trip safe pretty printing.
• Resolution: bounded depth-first search with iterative deepening (default — fair and terminating on finite programs), cut (!), and negation-as-failure (\+ / not). The engine is iterative, so deep searches use constant stack space.
• Unification with occurs check.
• Arithmetic (is/2): + - * / // mod rem abs min max sqrt, and the numeric comparisons =:= =\= < > =< >=.
• Term inspection: var/1 nonvar/1 atom/1 integer/1 float/1 number/1string/1 atomic/1 compound/1 ground/1 is_list/1.
• List built-ins: member/2, append/3, reverse/2, length/2, nth0/3, between/3.
• Output: write/1 and nl/0, collected into the query result.

#Quick start

///|
test {
  let program_text =
    #|parent(john, mary).
    #|parent(mary, ann).
    #|parent(mary, tom).
    #|ancestor(X, Y) :- parent(X, Y).
    #|ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).
  let p = Program::parse(program_text) catch { e => fail(e.message()) }
  assert_eq(p.query("ancestor(john, X)").answer_lines(), [
    "X = mary", "X = ann", "X = tom",
  ])
}

///|
test {
  let p = Program::parse("") catch { e => fail(e.message()) }
  assert_eq(p.query("X = f(Y), Y = 2").answer_lines(), ["X = f(2), Y = 2"])
  assert_eq(p.query("X is 1 + 2 * 3").answer_lines(), ["X = 7"])
  assert_eq(p.query("append(X, Y, [1, 2])").answer_lines(), [
    "X = [], Y = [1, 2]", "X = [1], Y = [2]", "X = [1, 2], Y = []",
  ])
}

///|
test {
  let p = Program::parse("") catch { e => fail(e.message()) }
  let r = p.query("(X = 1; X = 2), write(X), nl")
  assert_eq(r.output, "1\n2\n")
  assert_eq(r.answer_lines(), ["X = 1", "X = 2"])
}

#Search semantics

• iterative deepening: the depth limit grows until a round completes without hitting a bound (or max_depth is reached), so terminating searches produce the same answers, in the same order, as classic depth-first Prolog, while left-recursive programs cannot loop forever;
• at most max_steps inference steps and max_solutions answers per query; QueryResult::completion reports whether (and why) a bound cut the search space off.

#Command line

$ moon run cmd/prolog -- --query "member(X, [a, b, c])"
X = a
X = b
X = c

#Known limitations

• \+ searches within the current depth budget (bounded negation).
• Open-list generation is bounded (see length/2, member/2).
• The occurs check is always on, so X = f(X) fails.
• Strings are terms, not lists of character codes.

#License