eyeling 1.34.2 → 1.34.4

package/lib/eyelang/builtins/terms.js

@@ -0,0 +1,66 @@
+// Term-inspection builtins for reusable meta-programming over eyelang terms.
+import { atom, compound, deref, listFromItems, lexicalValue, numberTerm, properListItems, stringTerm, unify } from '../term.js';
+
+export const termBuiltins = {
+  register(registry) {
+    registry.add('functor', 3, functorBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
+    registry.add('arg', 3, argBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: argReady });
+    registry.add('compound_name_arguments', 3, compoundNameArguments, { deterministic: true, fallbackWhenNotReady: true, ready: compoundNameArgumentsReady });
+  }
+};
+
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
+function argReady(goal, env) {
+  return /^\d+$/.test(lexicalValue(goal.args[0], env) ?? '') && deref(goal.args[1], env).type === 'compound';
+}
+
+function compoundNameArgumentsReady(goal, env) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') return true;
+  return term.type === 'var' && lexicalValue(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
+function* functorBuiltin({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const nameTerm = term.type === 'compound' ? atom(term.name) : scalarNameTerm(term);
+  const arity = term.type === 'compound' ? term.arity : 0;
+  const next = env.clone();
+  if (unify(goal.args[1], nameTerm, next) && unify(goal.args[2], numberTerm(arity), next)) yield next;
+}
+
+function* argBuiltin({ goal, env }) {
+  const indexText = lexicalValue(goal.args[0], env);
+  if (!/^\d+$/.test(indexText ?? '')) return;
+  const index = Number(indexText);
+  const term = deref(goal.args[1], env);
+  if (term.type !== 'compound' || !Number.isSafeInteger(index) || index < 1 || index > term.arity) return;
+  const next = env.clone();
+  if (unify(goal.args[2], term.args[index - 1], next)) yield next;
+}
+
+function* compoundNameArguments({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') {
+    const next = env.clone();
+    if (unify(goal.args[1], atom(term.name), next) && unify(goal.args[2], listFromItems(term.args), next)) yield next;
+    return;
+  }
+  if (term.type !== 'var') return;
+
+  const name = lexicalValue(goal.args[1], env);
+  const args = properListItems(goal.args[2], env);
+  if (name == null || !args) return;
+  const next = env.clone();
+  if (unify(goal.args[0], compound(name, args), next)) yield next;
+}
+
+function scalarNameTerm(term) {
+  if (term.type === 'atom') return atom(term.name);
+  if (term.type === 'number') return numberTerm(term.name);
+  return stringTerm(term.name);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.34.2",
+  "version": "1.34.4",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/eyelang/conformance/README.md

@@ -36,7 +36,7 @@ The runner executes materialized programs in-process through the public JavaScri
 
 `core` covers the portable core language profile from the [eyelang language reference](../../../docs/eyelang-language-reference.md): lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification through user predicates, left-to-right goal-directed proof search, materialized output, and read-back printing.
 
-`extension` covers the standard built-in and host behavior exercised by the current reference implementation: arithmetic, comparison, strings, list relations, aggregation, context-term helpers, number-theory helpers, finite-search helpers used by the example corpus, matrix helpers, `memoize/2`, `materialize/2`, and default derived output.
+`extension` covers the standard built-in and host behavior exercised by the current reference implementation: arithmetic, comparison, strings, list relations, aggregation, context-term helpers, term-inspection helpers, search-control helpers, `memoize/2`, `materialize/2`, and default derived output.
 
 The profile name `extension` is a test-suite grouping name. It does not mean that these cases are outside the eyelang language reference; most of them correspond to the standard built-in profile and standard host profile in the [eyelang language reference](../../../docs/eyelang-language-reference.md).
 

package/test/eyelang/conformance/cases/extension/036_reusable_numeric_builtins.pl

@@ -0,0 +1,10 @@
+% Reference 9.1: reusable numeric functions and max/3.
+materialize(answer, 2).
+answer(max, X) :- max(17, 42, X).
+answer(sqrt, X) :- sqrt(81, X).
+answer(floor, X) :- floor(3.9, X).
+answer(ceiling, X) :- ceiling(3.1, X).
+answer(trunc, X) :- trunc(-3.9, X).
+answer(exp, X) :- exp(0, X).
+answer(tan, X) :- tan(0, X).
+answer(atan2, X) :- atan2(0, -1, X).

package/test/eyelang/conformance/cases/extension/037_reusable_list_builtins.pl

@@ -0,0 +1,11 @@
+% Reference 9.1: reusable list selectors, slices, summaries, and stable set conversion.
+materialize(answer, 2).
+answer(head, X) :- head([alpha, beta, gamma, beta], X).
+answer(last, X) :- last([alpha, beta, gamma, beta], X).
+answer(take, X) :- take(2, [alpha, beta, gamma, beta], X).
+answer(drop, X) :- drop(2, [alpha, beta, gamma, beta], X).
+answer(slice, X) :- slice(1, 2, [alpha, beta, gamma, beta], X).
+answer(sum, X) :- sum_list([1, 2, 3.5], X).
+answer(min, X) :- min_list([3, 1, 2], X).
+answer(max, X) :- max_list([3, 1, 2], X).
+answer(set, X) :- list_to_set([beta, alpha, beta, gamma, alpha], X).

package/test/eyelang/conformance/cases/extension/038_reusable_string_builtins.pl

@@ -0,0 +1,12 @@
+% Reference 9.1: reusable string normalization, splitting, joining, replacement, and conversions.
+materialize(answer, 2).
+answer(trim, X) :- trim("  Hello Eyelang  ", X).
+answer(lower, X) :- lowercase("Hello Eyelang", X).
+answer(upper, X) :- uppercase("Hello Eyelang", X).
+answer(split, X) :- split("red,green,blue", ",", X).
+answer(join, X) :- join([red, green, blue], ":", X).
+answer(substring, X) :- substring("abcdef", 2, 3, X).
+answer(replace, X) :- replace("red-green-red", "red", "blue", X).
+answer(number_to_string, X) :- number_string(42, X).
+answer(string_to_number, X) :- number_string(X, "3.5").
+answer(atom_string, X) :- atom_string(eyelang, X).

package/test/eyelang/conformance/cases/extension/039_reusable_term_control_builtins.pl

@@ -0,0 +1,11 @@
+% Reference 9.1: term introspection/construction, term strings, and forall/2.
+materialize(answer, 2).
+item(1).
+item(2).
+item(3).
+answer(functor, pair(Name, Arity)) :- functor(edge(a, b), Name, Arity).
+answer(arg, X) :- arg(2, edge(a, b), X).
+answer(decompose, pair(Name, Args)) :- compound_name_arguments(edge(a, b), Name, Args).
+answer(compose, X) :- compound_name_arguments(X, edge, [a, b]).
+answer(term_string, X) :- term_string(edge(a, [b, c]), X).
+answer(forall, ok) :- forall(item(X), lt(X, 4)).

package/test/eyelang/conformance/expected/extension/036_reusable_numeric_builtins.out

@@ -0,0 +1,8 @@
+answer(max, 42).
+answer(sqrt, 9.0).
+answer(floor, 3).
+answer(ceiling, 4).
+answer(trunc, -3).
+answer(exp, 1.0).
+answer(tan, 0.0).
+answer(atan2, 3.1415926535897931).

package/test/eyelang/conformance/expected/extension/037_reusable_list_builtins.out

@@ -0,0 +1,9 @@
+answer(head, alpha).
+answer(last, beta).
+answer(take, [alpha, beta]).
+answer(drop, [gamma, beta]).
+answer(slice, [beta, gamma]).
+answer(sum, 6.5).
+answer(min, 1).
+answer(max, 3).
+answer(set, [beta, alpha, gamma]).

package/test/eyelang/conformance/expected/extension/038_reusable_string_builtins.out

@@ -0,0 +1,10 @@
+answer(trim, "Hello Eyelang").
+answer(lower, "hello eyelang").
+answer(upper, "HELLO EYELANG").
+answer(split, ["red", "green", "blue"]).
+answer(join, "red:green:blue").
+answer(substring, "cde").
+answer(replace, "blue-green-blue").
+answer(number_to_string, "42").
+answer(string_to_number, 3.5).
+answer(atom_string, "eyelang").

package/test/eyelang/conformance/expected/extension/039_reusable_term_control_builtins.out

@@ -0,0 +1,6 @@
+answer(functor, pair(edge, 2)).
+answer(arg, b).
+answer(decompose, pair(edge, [a, b])).
+answer(compose, edge(a, b)).
+answer(term_string, "edge(a, [b, c])").
+answer(forall, ok).

package/examples/eyelang/collatz-1000.pl

@@ -1,14 +0,0 @@
-% Memoize trajectories because different start values quickly merge into
-% shared Collatz tails.
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(collatzTrajectory, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% Collatz trajectory benchmark adapted from Eyeling collatz-1000.n3.
-% The reusable builtin keeps this large output example focused on data volume
-% rather than recursive integer arithmetic overhead.
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-collatzTrajectory(N, Trajectory) :-
-  between(1, 1000, N),
-  collatz_trajectory(N, Trajectory).

package/examples/eyelang/complex-matrix-stability.pl

@@ -1,45 +0,0 @@
-% 2x2 continuous-time stability check.
-% For matrix [[a,b],[c,d]], a stable second-order linear system has
-% trace < 0 and determinant > 0.  A negative discriminant indicates a
-% complex-conjugate eigenvalue pair.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(trace, 2).
-materialize(determinant, 2).
-materialize(discriminant, 2).
-materialize(eigenShape, 2).
-materialize(status, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-matrix(controller_loop, -0.7, 1.2, -0.4, -0.5).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-trace(Matrix, Trace) :-
-  matrix(Matrix, A, _B, _C, D),
-  add(A, D, Trace).
-
-determinant(Matrix, Determinant) :-
-  matrix(Matrix, A, B, C, D),
-  mul(A, D, AD),
-  mul(B, C, BC),
-  sub(AD, BC, Determinant).
-
-discriminant(Matrix, Disc) :-
-  trace(Matrix, T),
-  determinant(Matrix, Det),
-  mul(T, T, T2),
-  mul(4, Det, FourDet),
-  sub(T2, FourDet, Disc).
-
-stable(Matrix) :-
-  trace(Matrix, T),
-  determinant(Matrix, Det),
-  lt(T, 0),
-  gt(Det, 0).
-
-complex_pair(Matrix) :-
-  discriminant(Matrix, Disc),
-  lt(Disc, 0).
-
-eigenShape(Matrix, complex_conjugate_pair) :- complex_pair(Matrix).
-status(Matrix, asymptotically_stable) :- stable(Matrix).

package/examples/eyelang/dense-hamiltonian-cycle.pl

@@ -1,92 +0,0 @@
-% Dense weighted Hamiltonian cycle search.
-%
-% This deliberately stresses finite search: it enumerates symmetry-broken
-% permutations of seven non-start vertices in an eight-vertex complete graph,
-% scores the closed cycles, and keeps the cheapest candidate with
-% aggregate_min/5.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(best, 2).
-materialize(candidateCount, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-cities([a, b, c, d, e, f, g, h]).
-
-edge(a, b, 3).
-edge(a, c, 47).
-edge(a, d, 35).
-edge(a, e, 46).
-edge(a, f, 34).
-edge(a, g, 45).
-edge(a, h, 10).
-edge(b, c, 4).
-edge(b, d, 42).
-edge(b, e, 30).
-edge(b, f, 41).
-edge(b, g, 52).
-edge(b, h, 40).
-edge(c, d, 5).
-edge(c, e, 37).
-edge(c, f, 48).
-edge(c, g, 36).
-edge(c, h, 47).
-edge(d, e, 6).
-edge(d, f, 32).
-edge(d, g, 43).
-edge(d, h, 31).
-edge(e, f, 7).
-edge(e, g, 50).
-edge(e, h, 38).
-edge(f, g, 8).
-edge(f, h, 45).
-edge(g, h, 9).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-weight(A, B, W) :- edge(A, B, W).
-weight(A, B, W) :- edge(B, A, W).
-
-permutation([], []).
-permutation(List, [X | Perm]) :-
-  select(X, List, Rest),
-  permutation(Rest, Perm).
-
-last([X], X).
-last([_ | Rest], X) :- last(Rest, X).
-
-path_cost([_Last], 0).
-path_cost([A, B | Rest], Cost) :-
-  weight(A, B, Step),
-  path_cost([B | Rest], Tail),
-  add(Step, Tail, Cost).
-
-symmetry_broken([First | Rest]) :-
-  last([First | Rest], Last),
-  lt(First, Last).
-
-candidate_cycle(Cities, Cycle, Cost) :-
-  weighted_hamiltonian_cycle(edge, Cities, Cycle, Cost).
-
-factorial(0, 1).
-factorial(N, F) :-
-  gt(N, 0),
-  sub(N, 1, N0),
-  factorial(N0, F0),
-  mul(N, F0, F).
-
-best(dense_hamiltonian_cycle, result(Cost, Cycle)) :-
-  cities(Cities),
-  aggregate_min([Cost, Cycle], result(Cost, Cycle), candidate_cycle(Cities, Cycle, Cost), _Key, result(Cost, Cycle)).
-
-candidateCount(dense_hamiltonian_cycle, Count) :-
-  cities([_Start | Rest]),
-  length(Rest, N),
-  factorial(N, Permutations),
-  div(Permutations, 2, Count).
-
-status(dense_hamiltonian_cycle, symmetry_broken_complete_graph_searched) :-
-  eq(ok, ok).
-
-reason(dense_hamiltonian_cycle, "symmetry-broken permutation search scores Hamiltonian cycles and aggregate_min selects the cheapest candidate") :-
-  eq(ok, ok).

package/examples/eyelang/gcd-bezout-identity.pl

@@ -1,48 +0,0 @@
-% EYE reasoning-inspired example: greatest common divisor and Bézout identity.
-%
-% This ports the extended Euclidean algorithm idea into ordinary eyelang rules.
-% Each case derives gcd(a,b), coefficients s,t, and validation checks for
-% a*s + b*t = gcd(a,b) and divisibility.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(gcd, 2).
-materialize(bezoutCoefficients, 2).
-materialize(check, 2).
-materialize(status, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-case(c1, 48, 18).
-case(c2, 101, 462).
-case(c3, 0, 5).
-case(c4, 270, 192).
-case(c5, -27, 36).
-case(c6, 123456, 7890).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-answer(Case, Gcd, S, T) :-
-  case(Case, A, B),
-  extended_gcd(A, B, Gcd, S, T).
-
-bezout_ok(Case) :-
-  case(Case, A, B),
-  answer(Case, Gcd, S, T),
-  mul(A, S, AS),
-  mul(B, T, BT),
-  add(AS, BT, Gcd).
-
-divides_ok(Case) :-
-  case(Case, A, B),
-  answer(Case, Gcd, S, T),
-  mod(A, Gcd, 0),
-  mod(B, Gcd, 0).
-
-nonnegative_ok(Case) :-
-  answer(Case, Gcd, S, T),
-  ge(Gcd, 0).
-
-gcd(Case, Gcd) :- answer(Case, Gcd, S, T).
-bezoutCoefficients(Case, [S, T]) :- answer(Case, Gcd, S, T).
-check(Case, bezout_identity) :- bezout_ok(Case).
-check(Case, divides_inputs) :- divides_ok(Case).
-check(Case, nonnegative_gcd) :- nonnegative_ok(Case).
-status(Case, done) :- answer(Case, Gcd, S, T), bezout_ok(Case), divides_ok(Case), nonnegative_ok(Case).

package/examples/eyelang/goldbach-1000.pl

@@ -1,185 +0,0 @@
-% Goldbach pairs up to 1000.
-% Prime numbers are input data; the rule below derives all Goldbach pairs.
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(isPrime, 2).
-materialize(goldbachOk, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-prime(2).
-prime(3).
-prime(5).
-prime(7).
-prime(11).
-prime(13).
-prime(17).
-prime(19).
-prime(23).
-prime(29).
-prime(31).
-prime(37).
-prime(41).
-prime(43).
-prime(47).
-prime(53).
-prime(59).
-prime(61).
-prime(67).
-prime(71).
-prime(73).
-prime(79).
-prime(83).
-prime(89).
-prime(97).
-prime(101).
-prime(103).
-prime(107).
-prime(109).
-prime(113).
-prime(127).
-prime(131).
-prime(137).
-prime(139).
-prime(149).
-prime(151).
-prime(157).
-prime(163).
-prime(167).
-prime(173).
-prime(179).
-prime(181).
-prime(191).
-prime(193).
-prime(197).
-prime(199).
-prime(211).
-prime(223).
-prime(227).
-prime(229).
-prime(233).
-prime(239).
-prime(241).
-prime(251).
-prime(257).
-prime(263).
-prime(269).
-prime(271).
-prime(277).
-prime(281).
-prime(283).
-prime(293).
-prime(307).
-prime(311).
-prime(313).
-prime(317).
-prime(331).
-prime(337).
-prime(347).
-prime(349).
-prime(353).
-prime(359).
-prime(367).
-prime(373).
-prime(379).
-prime(383).
-prime(389).
-prime(397).
-prime(401).
-prime(409).
-prime(419).
-prime(421).
-prime(431).
-prime(433).
-prime(439).
-prime(443).
-prime(449).
-prime(457).
-prime(461).
-prime(463).
-prime(467).
-prime(479).
-prime(487).
-prime(491).
-prime(499).
-prime(503).
-prime(509).
-prime(521).
-prime(523).
-prime(541).
-prime(547).
-prime(557).
-prime(563).
-prime(569).
-prime(571).
-prime(577).
-prime(587).
-prime(593).
-prime(599).
-prime(601).
-prime(607).
-prime(613).
-prime(617).
-prime(619).
-prime(631).
-prime(641).
-prime(643).
-prime(647).
-prime(653).
-prime(659).
-prime(661).
-prime(673).
-prime(677).
-prime(683).
-prime(691).
-prime(701).
-prime(709).
-prime(719).
-prime(727).
-prime(733).
-prime(739).
-prime(743).
-prime(751).
-prime(757).
-prime(761).
-prime(769).
-prime(773).
-prime(787).
-prime(797).
-prime(809).
-prime(811).
-prime(821).
-prime(823).
-prime(827).
-prime(829).
-prime(839).
-prime(853).
-prime(857).
-prime(859).
-prime(863).
-prime(877).
-prime(881).
-prime(883).
-prime(887).
-prime(907).
-prime(911).
-prime(919).
-prime(929).
-prime(937).
-prime(941).
-prime(947).
-prime(953).
-prime(967).
-prime(971).
-prime(977).
-prime(983).
-prime(991).
-prime(997).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-even_between_4_1000(N) :- between(4, 1000, N), mod(N, 2, 0).
-
-isPrime(N, true) :-
-  prime(N).
-
-goldbachOk(N, true) :-
-  even_between_4_1000(N),
-  goldbach_pair(N, _P, _Q).

package/examples/eyelang/hamiltonian-cycle.pl

@@ -1,55 +0,0 @@
-% Hamiltonian cycle without cut.
-%
-% The graph has eight vertices and enough chords to create a non-trivial search
-% space.  The first vertex is fixed to avoid rotational duplicates; the two
-% cycle directions are still distinct, so the count is for cycles from a fixed
-% start in traversal order.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(status, 2).
-materialize(witness, 2).
-materialize(vertexCount, 2).
-materialize(cycleCountFromA, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-edge(a, b).
-edge(a, f).
-edge(a, g).
-edge(a, h).
-edge(b, c).
-edge(b, d).
-edge(b, g).
-edge(b, h).
-edge(c, d).
-edge(c, e).
-edge(c, g).
-edge(d, e).
-edge(d, g).
-edge(d, h).
-edge(e, f).
-edge(f, g).
-edge(g, h).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-adjacent(X, Y) :- edge(X, Y).
-adjacent(X, Y) :- edge(Y, X).
-
-vertices([a, b, c, d, e, f, g, h]).
-
-hamiltonian_cycle(Cycle) :-
-  vertices(Vertices),
-  hamiltonian_cycle(edge, Vertices, Cycle).
-
-status(hamiltonian_cycle, exists) :-
-  once(hamiltonian_cycle(_Cycle)).
-
-witness(hamiltonian_cycle, Cycle) :-
-  once(hamiltonian_cycle(Cycle)).
-
-vertexCount(hamiltonian_cycle, Count) :-
-  vertices(Vertices),
-  length(Vertices, Count).
-
-cycleCountFromA(hamiltonian_cycle, Count) :-
-  findall(Cycle, hamiltonian_cycle(Cycle), Cycles),
-  length(Cycles, Count).

package/examples/eyelang/kaprekar.pl

@@ -1,32 +0,0 @@
-% Kaprekar's constant demo, adapted from Eyelet's input/kaprekar.pl.
-%
-% This is deliberately a rule-level example, not a native builtin.  It extracts
-% four digits, sorts them, subtracts ascending from descending, and recurses
-% until Kaprekar's constant 6174 is reached.  The sample set is small so the
-% example remains a millisecond-scale demo in the normal test suite.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(constant, 2).
-materialize(kaprekarSteps, 2).
-materialize(reachesConstant, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-memoize(kaprekar, 3).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-recursion_count(N, Count) :-
-  kaprekar_steps(N, Count).
-
-sample(3524).
-sample(2111).
-sample(9831).
-sample(6174).
-constant(kaprekar, 6174).
-
-kaprekarSteps(N, Count) :-
-  sample(N),
-  recursion_count(N, Count).
-
-reachesConstant(kaprekar, N) :-
-  sample(N),
-  recursion_count(N, _Count).