Ruby.CodeCompared.To/Prolog

The line beginning with :- is a directive — a goal that Prolog runs immediately when it reads the program. writeln/1 writes its argument followed by a newline. There is no main function in Prolog; the program is the goal.

A fact like person(alice). declares something true. forall/2 walks every solution of its first argument and runs the second for each. Notice the lowercase names — in Prolog, lowercase identifiers are atoms (constants), while uppercase are variables.

The single most important Prolog rule: capitalization determines meaning. alice is an atom (a literal name). X is a variable — a placeholder that the engine tries to bind to a value. This is the opposite of Ruby, where X is just a (warned-against) constant name.

The query likes(alice, Thing) asks: "for what values of Thing is this fact true?" Prolog finds every match automatically — no loop, no filter, no enumerable. The engine's job is to enumerate solutions; yours is to describe the relationship.

Each fact is a relation: book(Title, Author, Year) is a 3-place relation, written book/3. format/2 is Prolog's printf: ~w writes a term, ~n emits a newline. Facts are arguments-only — there are no named fields.

= in Prolog is unification, not assignment. It makes both sides structurally identical, binding variables as needed. foo(A, B) = foo(1, 2) matches the two terms, binding A=1 and B=2 in a single step. This is the engine's core operation.

Unification fails when terms cannot be made identical: 1 cannot unify with 3. Prolog 4.0's pattern matching (case/in) is a near-parallel — both descend through structure and bind variables, both fail when the structure disagrees.

The underscore _ is the anonymous variable — every occurrence is a fresh, unrelated variable. Use it when you need to acknowledge a position without naming it. This is exactly Ruby's |first, _| convention, but enforced by the engine: _ never binds.

Unification descends through nested structure. person(name(N), age(A)) matches person(name(alice), age(30)) by recursively unifying each sub-term. This is how Prolog inspects data — there is no separate "destructure" operation.

Once a Prolog variable is bound, it stays bound for the rest of that proof. X = 1, X = 2 tries to unify the already-bound X with 2 — and fails. There is no mutation in pure Prolog; "rebinding" requires fresh variables.

Read :- as "if". The rule says: Grandparent is a grandparent of Grandchild if there exists a Parent in between. The comma is logical "AND". Prolog tries every combination of values that makes the body true.

The comma , means "and". Each subgoal must succeed for the rule to fire. Goals are tried left-to-right; if one fails, Prolog backtracks — it undoes earlier bindings and tries different choices to make the conjunction work.

The semicolon ; means "or". It can appear inside a rule body. More commonly, "or" is expressed by writing multiple clauses — each clause is an alternative way for the head to be true. Both forms behave the same; multi-clause style is more idiomatic.

Two facts with the same head form a disjunction: anything that matches either clause succeeds. This is the most common style — you read it top-to-bottom as a series of alternatives the engine will try in order.

\+ Goal succeeds when Prolog cannot prove Goal — known as "negation as failure". This is not logical negation: it assumes the database is closed (anything not provable is false). The escape \\+ in the JS template becomes a literal \+ in the program.

Two distinct operators. X = 2 + 3 unifies X with the compound term 2+3 — it does not compute. Y is 2 + 3 forces arithmetic evaluation and binds Y to 5. Forgetting this distinction is the most common Prolog beginner bug.

Prolog distinguishes float division / from integer division //, similar to Python. mod is the modulo operator. The right-hand side of is must contain only numbers and arithmetic operators — passing an unbound variable raises an error.

Prolog supports the usual math functions on the right of is: abs, min, max, sqrt, sin, cos, log, exp, and more. These are functions (not predicates) — they appear only inside arithmetic evaluation.

between(Low, High, X) succeeds when X is an integer in that range — and generates each one in turn on backtracking. It plays the same role as Ruby's 1..5, but as a relation: you can also test whether a known value falls in range.

succ(X, Y) means "Y is the successor of X" — that is, Y = X + 1, with both X and Y non-negative integers. Like most Prolog predicates it is relational: given either argument, it computes the other. This bidirectionality is the heart of Prolog.

For numbers use <, >, =<, >=, =:= (numerically equal), and =\= (numerically different). Both sides must be fully evaluable expressions. Unlike =, these never bind variables — they only compare.

=:= evaluates both sides as arithmetic. == asks whether the two terms are structurally identical — and 1+2 is the compound +(1,2), which is not identical to the integer 3. Choose the comparison based on what kind of equality you mean.

X \= Y succeeds when X and Y cannot be unified. Note the second case: foo(X) \= foo(1) fails, because the variable X can unify with 1. This is different from saying X is not equal to 1 — it asks whether they can be made identical.

Prolog defines a total order on all terms: numbers < atoms < strings < compound terms. The @<, @>, @=<, @>= operators compare terms in this order. msort/2 sorts a list using this order, regardless of element type.

compare(Order, X, Y) binds Order to <, =, or > depending on the standard order of terms. It corresponds to Ruby's spaceship <=>, but works on any pair of terms — not just comparables.

Prolog lists use the same [...] syntax as Ruby. Internally they are linked structures built from a "cons" operator and the empty list []. length/2 relates a list to its length — given the list, it computes the length; given only a length, it generates a list of fresh variables.

The pipe | separates the first element from the rest: [Head | Tail] matches any non-empty list. This is destructuring by unification — the same operation that drives every Prolog match. You can split off more: [A, B | Rest] peels two elements.

member(X, List) succeeds when X is an element of List. Like most Prolog predicates it works two ways: with a bound X, it tests membership; with an unbound X, it generates each member in turn through backtracking.

append(A, B, C) means "C is the concatenation of A and B". A single rule answers three questions: concatenate (A, B known), split (C known), or generate all pairs that concatenate to a given list. Ruby needs three separate algorithms for the same task.

reverse(List, Reversed) reverses a list. It is a built-in but is also a classic first recursive exercise — the textbook implementation walks the list and accumulates into a second list, which produces the reverse for free.

Prolog has both nth0/3 (zero-indexed, like Ruby) and nth1/3 (one-indexed, like the natural numbering "first, second, third"). Picking your conventions explicitly is more pleasant than guessing.

The Prolog pattern: a base case clause for empty/zero, plus a recursive case that peels one element and relates the smaller problem to the answer. There is no loop construct — every iteration in Prolog is a recursive call.

The same shape as length: empty list sums to 0; non-empty list sums to head plus the sum of the tail. The standard library actually provides sum_list/2 already; writing it yourself is the canonical "first useful recursion" exercise.

The two clauses cover the two cases by pattern: factorial(0, 1) handles the base, and the rule handles positive N. The guard N > 0 prevents the rule from being tried for the base case, where its body would loop infinitely.

Three clauses, three cases. This is the naive recursive Fibonacci — exponential in time, just like the Ruby version. Real Prolog programs would use an accumulator or memoization (via assertz/1) for efficiency.

A side-effecting recursion: walk the list, print, recurse. The base case does nothing (the empty list has nothing to print). In idiomatic Prolog you would write forall(member(X, List), writeln(X)) — but writing the recursion by hand exposes the underlying shape.

An atom is a symbolic constant — like a Ruby symbol but without the leading colon. Lowercase identifiers are atoms; any text inside single quotes is also an atom. Double-quoted text is a string in Tau Prolog and most modern Prologs.

atom_concat/3 joins two atoms — and like append/3, it runs backwards: given the result, it finds every way to split it into two pieces. The trailing fail ; true drives the loop through every split, then succeeds at the end.

atom_length(Atom, Length) relates an atom to its character count. As always: bound atom, computes length; bound length, generates fresh atoms of that length (less commonly useful).

atom_chars(Atom, Chars) converts between an atom and a list of one-character atoms. The relational design means the same predicate splits and joins. atom_codes/2 is the analogous predicate that uses integer character codes instead.

number_chars(Number, Chars) relates a number to a list of one-character atoms. Combined with atom_chars/2, it converts between atoms and numbers either way. The standard does not provide a single direct predicate — going through characters is the portable approach.

Conjunction backtracks like nested loops. Each color(Color) picks a value; for that choice, size(Size) picks a value; the body fires. When the body completes, the engine asks for the next size, then the next color, automatically. This is the Prolog version of nested iteration.

The cut ! commits to the current clause — it tells the engine "don't try other clauses for this predicate". This turns a multi-clause definition into an if/elsif chain. Used carefully, the cut makes definitions efficient and deterministic; overused, it sabotages the relational nature of the language.

The classical Prolog idiom for "do this for each solution". fail forces backtracking; the engine retries member, picks the next value, runs the body again. When member exhausts its choices, control passes to ; true so the directive succeeds. Modern code prefers forall/2.

(Cond -> Then ; Else) is Prolog's if-then-else. If Cond succeeds, only Then runs and the choice is committed; otherwise Else runs. Without the -> arrow you have a plain disjunction, which behaves very differently — it leaves both branches as backtracking choice points.

once(Goal) succeeds with the first solution of Goal and then commits — no backtracking into Goal. It is equivalent to (Goal, !) wrapped to scope the cut. Use it whenever you want "the first one that works" without retrying.

write/1 writes a term without a trailing newline. writeln/1 is the same plus nl. The argument can be any term: atoms, numbers, lists, compound structures — Prolog writes a textual representation of each.

nl/0 writes a single newline. It is the lower-level partner to writeln/1. Spell out write + nl when you want to compose output from multiple terms before ending the line.

format/2 is Prolog's printf. Placeholders: ~w writes any term, ~a writes atoms, ~d writes integers, ~n emits a newline. The second argument is a list of values matched to placeholders in order.

writeq/1 writes a term in a form that can be read back as input — atoms with special characters get quoted, operators get parentheses if needed. write/1 is for humans; writeq/1 is for round-tripping.

maplist(Predicate, List) succeeds when Predicate is true of every element. The predicate is named by an atom and looked up like any other rule. This is Ruby's .all?, but the "block" is a separately-defined named relation.

maplist(P, In, Out) applies a 2-place predicate to each input and collects each result. double/2 relates an input to its double. This is Ruby's .map, with the relation explicitly named. The /2 means "two arguments".

maplist/4 takes a 3-place predicate plus three lists of equal length, applying the predicate element-wise. It generalises naturally to maplist/5, maplist/6, etc. — Prolog's metaprogramming makes that uniform.

call(Goal) invokes a goal stored as data. call(P, Arg) adds an extra argument before calling. This is how higher-order predicates pass partially-applied goals — bigger_than(5) is a "callable" with one slot still to fill, just like a lambda.

forall(Cond, Action) succeeds when, for every solution of Cond, Action also succeeds. It is the relational version of "for all X in C, P(X)". A common idiom: pair it with member/2 to express "every element satisfies...".

findall(Template, Goal, List) collects every solution of Goal, instantiating Template for each, into a list. It always succeeds, even if there are no solutions — in which case List is [].

bagof/3 is like findall/3, but it fails when there are no solutions instead of binding to []. Use it when "no answers" is meaningful and should propagate as failure, not as an empty list.

setof/3 collects solutions, sorts them, and removes duplicates. The Who^ says "existentially quantified" — we don't care who picked each color, we just want the colors. Without that marker, setof would group results per distinct Who.

A classic pattern: findall/3 harvests every solution into a list, then list-processing predicates aggregate. sum_list/2, max_list/2, min_list/2, length/2 all work this way.

assertz/1 adds a new fact to the database at the end; asserta/1 adds at the start. The :- dynamic(name/arity). declaration is required: it tells Prolog this predicate can be modified at runtime, which a pure logic program normally cannot do.

retract/1 removes the first matching clause. Asserts and retracts together let Prolog programs maintain mutable state — but at the cost of pure logical reasoning. Treat them as side-effects, like Ruby's instance variables.

The cycle retract → arithmetic → assertz updates a single fact in place. It is the Prolog way to simulate an assignable variable. In real Prolog code, prefer threading state through arguments — but for genuinely global state, this is the idiom.

You can assert rules, not just facts, by wrapping the clause in parentheses. The added clauses are immediately usable. This is Prolog's metaprogramming: code that writes code, then runs it. Ruby's define_method is the closest mainstream analogue.

The canonical Prolog example. Two clauses for ancestor cover the two cases: a direct parent, or a parent of an ancestor. The same definition answers "is X an ancestor of Y?", "who are X's descendants?", and "who are Y's ancestors?" — all from one rule, free.

Graph traversal as logical declaration: a path either is an edge, or is an edge followed by a path. The recursive clause builds the route by accumulating in a list. Note the cycle hazard: this naive version assumes the graph is acyclic. A real implementation tracks visited nodes.

Two clauses: a single-element list is its own minimum; a longer list's minimum is whichever is smaller, the head or the minimum of the tail. The if-then-else picks one. The base case could use [X] instead of [Single] for the same effect.

Three clauses: empty list and single-element list are trivially sorted; a longer list is sorted if the first two elements are in order and the tail (without the head) is also sorted. Sliding a two-element window is natural in head-tail patterns.

The accumulator pattern. Each recursive call moves one element from the input list onto the front of the accumulator — when the input is empty, the accumulator is the answer. This is linear time, unlike the naive append-based reverse, which is quadratic.