Capstone — Building a Small Project

The final chapter of the full Prolog track. This capstone builds a real N-Queens solver — combining prolog2-7's CLP(FD), prolog1-8's cut, prolog2-1's findall, and prolog2-5's DCG notation into one working project — and closes with the comparison this entire track was framed around from its very first chapter: two languages, both routinely called "declarative," solving computation in genuinely different ways.

The Problem — N-Queens

Place N queens on an N×N chessboard so that no two attack each other — no shared row, no shared column, no shared diagonal. A classic constraint-satisfaction problem, and exactly the shape prolog2-7 named as CLP(FD)'s natural strength.

Modeling With CLP(FD)

Queens is a list of N domain variables, one per column, each holding that column's queen's row — column position is implicit in the list index, so "no shared column" is automatic. ins is prolog2-7's own in, pluralized to apply one domain declaration to an entire list at once. safe_queens/1 walks the list, posting a #\= (row clash) and a diagonal-distance constraint between every pair of queens — real unification and real constraint propagation, narrowing the search before label/1 ever commits to a single value.

One Solution vs. All Solutions

The cut after queens(4, Qs) is prolog1-8's own backtracking-control tool, put to genuine use — it commits to the first solution label/1 finds rather than leaving choice points open for a caller who only wants one answer. findall — prolog2-1's own meta-predicate — does the opposite: it drives queens/2 to exhaustion, collecting every valid 6-queens board into one list. Four is the well-known correct count of distinct solutions for N = 6.

Rendering a Board With a DCG

prolog2-5's --> notation, reused to generate a row rather than parse one — DCGs run perfectly well in either direction. For each column C, symbol/2 emits q if that column's queen sits in the row currently being rendered, otherwise e.

The cut in symbol(Row, Row) --> !, [q]. is genuinely load-bearing, not just tidy — and it's a red cut by prolog1-8's own test. Without it, backtracking into symbol/2 at a queen's own column could still also match the catch-all second clause, producing an additional, factually wrong reading of that cell as empty. Removing this cut would genuinely change which results the predicate can produce — the defining test for red vs. green.

One last, quiet connection: forall/2 is standardly defined as forall(Cond, Action) :- \+ (Cond, \+ Action). — double negation, built directly from prolog2-3's own \+. This capstone never calls \+ by name, but it's running underneath every row printed, exactly the way prolog2-6 showed a meta-predicate can be a thin layer reusing something more fundamental.

Chapter Attribution

Two Declarative Paradigms — Closing the Prolog Track

Every earlier chapter that named Haskell did so piece by piece — unification against pattern matching, backtracking against the [] monad, cut and assert against unsafePerformIO. This capstone is the place to say the whole comparison plainly, using N-Queens itself as the concrete anchor.

A Haskell N-Queens solver would be a genuine function — most naturally built over the [] monad's own do-notation (haskell2-3), generating candidate placements, filtering out attacking ones, and returning a concrete list of valid boards as its result. The search is real, but it's expressed as ordinary values flowing through ordinary function composition — solve(N) :: [[Int]] is a pure computation, evaluated to produce a value, the same as any other Haskell expression.

This chapter's queens/2 is not a function computing a value — it's a relation, and Queens is not returned so much as discovered: a set of variable bindings that happen to satisfy every constraint posted against them, found by an engine built to search exactly that way. CLP(FD) makes the search efficient, but it doesn't change what's actually happening underneath — Prolog was never evaluating an expression to a value; it was finding bindings that make a relation true.

Both are honestly "declarative" — neither language makes you write an explicit loop or a mutable counter to find these boards. But they earn that label in two structurally different ways, and this whole track, from prolog1-1's very first "no main" surprise to this capstone's own solver, has been the concrete demonstration of exactly what that difference looks like in practice.

Coding Challenges