eyeling 1.34.3 → 1.34.5

package/lib/eyelang/builtins/lists.js

@@ -1,23 +1,62 @@
-// List builtins for proper lists, selection, membership, sorting, and indexing.
+// List builtins for proper lists, selection, membership, sorting, indexing, slicing, and summaries.
 // Several predicates support both checking and generation, so the argument modes are handled explicitly.
-import { compareTerms, copyResolved, deref, isCons, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
+import {
+  compareTerms,
+  copyResolved,
+  deref,
+  isDecimalInteger,
+  isCons,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  numberTextFromDouble,
+  parseFiniteNumber,
+  properListItems,
+  unify,
+} from '../term.js';
 
 export const listBuiltins = {
   register(registry) {
     registry.add('append', 3, append);
     registry.add('nth0', 3, nth0);
     registry.add('set_nth0', 4, setNth0, { deterministic: true });
-    registry.add('rest', 2, rest, { deterministic: true });
+    registry.add('head', 2, head, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('rest', 2, rest, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('last', 2, last, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('take', 3, take, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('drop', 3, drop, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('slice', 4, slice, { deterministic: true, fallbackWhenNotReady: true, ready: sliceReady });
     registry.add('member', 2, member);
     registry.add('select', 3, select);
     registry.add('not_member', 2, notMember, { deterministic: true });
     registry.add('reverse', 2, reverse, { deterministic: true });
     registry.add('length', 2, lengthBuiltin, { deterministic: true });
+    registry.add('sum_list', 2, sumList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('min_list', 2, minList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('max_list', 2, maxList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('list_to_set', 2, listToSet, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
     registry.add('sort', 2, sortBuiltin, { deterministic: true });
   }
 };
 
 
+
+function firstConsReady(goal, env) {
+  return isCons(deref(goal.args[0], env));
+}
+
+function firstProperListReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null;
+}
+
+function countAndListReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && properListItems(goal.args[1], env) !== null;
+}
+
+function sliceReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
 function listFromItemsExcept(items, skip) {
   const copy = new Array(items.length - 1);
   for (let i = 0, j = 0; i < items.length; i++) if (i !== skip) copy[j++] = items[i];
@@ -62,10 +101,8 @@ function* nth0({ goal, env }) {
 }
 
 function* setNth0({ goal, env }) {
-  const indexText = lexicalValue(goal.args[0], env);
-  if (!/^-?\d+$/.test(indexText ?? '')) return;
-  const index = Number(indexText);
-  if (!Number.isSafeInteger(index) || index < 0) return;
+  const index = safeIndex(goal.args[0], env);
+  if (index == null) return;
   const items = properListItems(goal.args[1], env);
   if (!items || index >= items.length) return;
   const out = items.slice();
@@ -74,6 +111,13 @@ function* setNth0({ goal, env }) {
   if (unify(goal.args[3], listFromItems(out), next)) yield next;
 }
 
+function* head({ goal, env }) {
+  const list = deref(goal.args[0], env);
+  if (!isCons(list)) return;
+  const next = env.clone();
+  if (unify(goal.args[1], list.args[0], next)) yield next;
+}
+
 function* rest({ goal, env }) {
   const list = deref(goal.args[0], env);
   if (!isCons(list)) return;
@@ -81,6 +125,41 @@ function* rest({ goal, env }) {
   if (unify(goal.args[1], list.args[1], next)) yield next;
 }
 
+function* last({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  const next = env.clone();
+  if (unify(goal.args[1], items[items.length - 1], next)) yield next;
+}
+
+function* take({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, 0, count), next)) yield next;
+}
+
+function* drop({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, count, items.length), next)) yield next;
+}
+
+function* slice({ goal, env }) {
+  const start = safeIndex(goal.args[0], env);
+  const count = safeIndex(goal.args[1], env);
+  if (start == null || count == null) return;
+  const items = properListItems(goal.args[2], env);
+  if (!items || start + count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], listFromItems(items, start, start + count), next)) yield next;
+}
+
 function* member({ goal, env }) {
   const items = properListItems(goal.args[1], env);
   if (!items) return;
@@ -132,6 +211,59 @@ function* lengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(items.length), next)) yield next;
 }
 
+function* sumList({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  let intSum = 0n;
+  let floatMode = false;
+  let floatSum = 0;
+  for (const item of items) {
+    const text = lexicalValue(item, env);
+    if (text == null) return;
+    if (!floatMode && isDecimalInteger(text)) intSum += BigInt(text);
+    else {
+      const value = parseFiniteNumber(text);
+      if (value == null) return;
+      if (!floatMode) { floatSum = Number(intSum); floatMode = true; }
+      floatSum += value;
+    }
+  }
+  const out = floatMode ? numberTextFromDouble(floatSum) : intSum.toString();
+  const next = env.clone();
+  if (unify(goal.args[1], numberTerm(out), next)) yield next;
+}
+
+function* minList({ goal, env }) {
+  yield* minMaxList(goal, env, true);
+}
+
+function* maxList({ goal, env }) {
+  yield* minMaxList(goal, env, false);
+}
+
+function* minMaxList(goal, env, wantMin) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  let best = copyResolved(items[0], env);
+  for (let i = 1; i < items.length; i++) {
+    const item = copyResolved(items[i], env);
+    const cmp = compareTerms(item, best);
+    if ((wantMin && cmp < 0) || (!wantMin && cmp > 0)) best = item;
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], best, next)) yield next;
+}
+
+function* listToSet({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  const unique = [];
+  for (const item of items.map((entry) => copyResolved(entry, env))) {
+    if (!unique.some((seen) => compareTerms(seen, item) === 0)) unique.push(item);
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems(unique), next)) yield next;
+}
 
 function* sortBuiltin({ goal, env }) {
   const items = properListItems(goal.args[0], env);
@@ -142,3 +274,10 @@ function* sortBuiltin({ goal, env }) {
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(unique), next)) yield next;
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}

package/lib/eyelang/builtins/registry.js

@@ -7,8 +7,7 @@ import { listBuiltins } from './lists.js';
 import { aggregationBuiltins } from './aggregation.js';
 import { contextBuiltins } from './context.js';
 import { controlBuiltins } from './control.js';
-import { numberTheoryBuiltins } from './number-theory.js';
-import { matrixBuiltins } from './matrix.js';
+import { termBuiltins } from './terms.js';
 
 export class BuiltinRegistry {
   constructor() {
@@ -35,7 +34,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, numberTheoryBuiltins, matrixBuiltins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, termBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/lib/eyelang/builtins/strings.js

@@ -1,16 +1,76 @@
 // String builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { compound, lexicalValue, stringTerm, unify } from '../term.js';
+import {
+  atom,
+  compound,
+  deref,
+  isDecimalInteger,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  parseFiniteNumber,
+  properListItems,
+  stringTerm,
+  termToString,
+  unify,
+} from '../term.js';
 
 export const stringBuiltins = {
   register(registry) {
     registry.add('str_concat', 3, concat, { deterministic: true });
     for (const name of ['contains', 'matches', 'not_matches']) registry.add(name, 2, contains(name), { deterministic: true });
     registry.add('matches', 3, matchCaptures, { deterministic: true });
+    registry.add('split', 3, split, { deterministic: true, fallbackWhenNotReady: true, ready: firstTwoLexicalReady });
+    registry.add('join', 3, join, { deterministic: true, fallbackWhenNotReady: true, ready: listAndSecondLexicalReady });
+    registry.add('substring', 4, substring, { deterministic: true, fallbackWhenNotReady: true, ready: substringReady });
+    registry.add('replace', 4, replace, { deterministic: true, fallbackWhenNotReady: true, ready: firstThreeLexicalReady });
+    registry.add('lowercase', 2, caseFold('lower'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('uppercase', 2, caseFold('upper'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('trim', 2, trim, { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('number_string', 2, numberString, { deterministic: true, fallbackWhenNotReady: true, ready: numberStringReady });
+    registry.add('atom_string', 2, atomString, { deterministic: true, fallbackWhenNotReady: true, ready: atomStringReady });
+    registry.add('term_string', 2, termString, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
   }
 };
 
 
+
+function firstLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null;
+}
+
+function firstTwoLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function firstThreeLexicalReady(goal, env) {
+  return firstTwoLexicalReady(goal, env) && lexicalValue(goal.args[2], env) !== null;
+}
+
+function listAndSecondLexicalReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function substringReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && safeIndex(goal.args[2], env) !== null;
+}
+
+function numberStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'number' || right.type === 'string' || right.type === 'atom';
+}
+
+function atomStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'atom' || right.type === 'string' || right.type === 'atom' || right.type === 'number';
+}
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
 function* concat({ goal, env }) {
   const left = lexicalValue(goal.args[0], env);
   const right = lexicalValue(goal.args[1], env);
@@ -53,6 +113,99 @@ function* matchCaptures({ goal, env }) {
   if (unify(goal.args[2], context, next)) yield next;
 }
 
+function* split({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (text == null || separator == null) return;
+  const parts = text.split(separator).map(stringTerm);
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(parts), next)) yield next;
+}
+
+function* join({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (!items || separator == null) return;
+  const strings = [];
+  for (const item of items) {
+    const value = lexicalValue(item, env);
+    if (value == null) return;
+    strings.push(value);
+  }
+  const next = env.clone();
+  if (unify(goal.args[2], stringTerm(strings.join(separator)), next)) yield next;
+}
+
+function* substring({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const start = safeIndex(goal.args[1], env);
+  const count = safeIndex(goal.args[2], env);
+  if (text == null || start == null || count == null || start + count > text.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(text.slice(start, start + count)), next)) yield next;
+}
+
+function* replace({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const search = lexicalValue(goal.args[1], env);
+  const replacement = lexicalValue(goal.args[2], env);
+  if (text == null || search == null || replacement == null) return;
+  const out = search === '' ? text : text.split(search).join(replacement);
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(out), next)) yield next;
+}
+
+function caseFold(direction) {
+  return function* ({ goal, env }) {
+    const text = lexicalValue(goal.args[0], env);
+    if (text == null) return;
+    const next = env.clone();
+    const out = direction === 'lower' ? text.toLowerCase() : text.toUpperCase();
+    if (unify(goal.args[1], stringTerm(out), next)) yield next;
+  };
+}
+
+function* trim({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  if (text == null) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(text.trim()), next)) yield next;
+}
+
+function* numberString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'number') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom') {
+    if (!numericText(right.name)) return;
+    if (unify(goal.args[0], numberTerm(right.name), next)) yield next;
+  }
+}
+
+function* atomString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'atom') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom' || right.type === 'number') {
+    if (unify(goal.args[0], atom(right.name), next)) yield next;
+  }
+}
+
+function* termString({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(termToString(term, env, true)), next)) yield next;
+}
+
 function contextFromGroups(groups) {
   const terms = [];
   for (const [name, value] of Object.entries(groups)) {
@@ -68,3 +221,14 @@ function contextFromGroups(groups) {
 function simpleAlternationMatch(haystack, pattern) {
   return pattern.split('|').some((part) => part === '' || haystack.includes(part));
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}
+
+function numericText(text) {
+  return isDecimalInteger(text) || parseFiniteNumber(text) != null;
+}

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.3",
+  "version": "1.34.5",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/eyelang/conformance/README.md

@@ -4,8 +4,8 @@ This directory contains the executable conformance cases for the eyelang languag
 
 The suite is intentionally file-based so another implementation can run the same programs and compare exact standard output. A case consists of:
 
-- `conformance/cases/<profile>/<name>.pl` — input program;
-- `conformance/expected/<profile>/<name>.out` — exact expected standard output.
+- `conformance/cases/<name>.pl` — input program;
+- `conformance/expected/<name>.pl` — exact expected standard output, stored as eyelang-readable facts.
 
 The current runner compares standard output from normal execution. Proof explanations are opt-in in the CLI and are not part of these conformance goldens. Standard error, performance, and resource limits are outside this suite.
 
@@ -23,23 +23,21 @@ Run only the conformance suite:
 node test/eyelang/run-conformance.mjs
 ```
 
-Run a single conformance profile directly:
+Run matching conformance cases by passing a filename fragment:
 
 ```sh
-node test/eyelang/run-conformance.mjs core
-node test/eyelang/run-conformance.mjs extension
+node test/eyelang/run-conformance.mjs reusable
+node test/eyelang/run-conformance.mjs 092_scalar_string_conversions
 ```
 
 The runner executes materialized programs in-process through the public JavaScript API so small conformance cases avoid measuring Node startup overhead.
 
-## Profiles
+## Scope
 
-`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.
+The conformance corpus is a single eyelang suite. It covers the standard language described by the language reference: lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification, left-to-right goal-directed proof search, materialized output, read-back printing, standard built-ins, declarations, and standard host behavior.
 
-`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, matrix 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).
+The suite deliberately does not separate `core` and `extension` profiles. Reusable built-ins such as arithmetic, strings, lists, aggregation, context terms, term inspection, and search control are part of the standard eyelang conformance surface. Implementation-specific built-ins may still exist in downstream hosts, but they should have their own tests outside this corpus unless they are standardized.
 
 ## Updating expected output
 
-There is no committed auto-accept mode. To update an expected file, run the matching case with the conformance runner, inspect the result, and replace the corresponding file under `conformance/expected/<profile>/` deliberately.
+There is no committed auto-accept mode. To update an expected file, run the matching case with the conformance runner, inspect the result, and replace the corresponding file under `conformance/expected/` deliberately.

package/test/eyelang/conformance/cases/001_fact_output.pl

@@ -0,0 +1,4 @@
+% Reference 6, 7, 11: facts can be exposed through a materialized derived predicate.
+materialize(parent, 2).
+base_parent(pat, jan).
+parent(X, Y) :- base_parent(X, Y).

package/test/eyelang/conformance/cases/002_rule_recursion.pl

@@ -0,0 +1,7 @@
+% Reference 6, 7: definite clauses, conjunction, and recursive proof search.
+materialize(ancestor, 2).
+parent(pat, jan).
+parent(jan, emma).
+ancestor_any(X, Y) :- parent(X, Y).
+ancestor_any(X, Z) :- parent(X, Y), ancestor_any(Y, Z).
+ancestor(pat, Y) :- ancestor_any(pat, Y).

package/test/eyelang/conformance/cases/002_rule_recursion.query

@@ -0,0 +1 @@
+ancestor(pat, X)

package/test/eyelang/conformance/cases/003_terms_and_readback.pl

@@ -0,0 +1,16 @@
+% Reference 3, 5, 11: scalars, compounds, lists, and read-back printing.
+materialize(value, 2).
+raw_value(atom, pat).
+raw_value(quoted_atom, 'atom with spaces').
+raw_value(quoted_quote, 'needs''quote').
+raw_value(empty_atom, '').
+raw_value(string, "line\nquote: \"ok\"").
+raw_value(integer, -42).
+raw_value(decimal, 0.25).
+raw_value(scientific, 1.25e-3).
+raw_value(compound, pair(3, nested(atom, [x, y]))).
+raw_value(zero_arity, nil()).
+raw_value(empty_list, []).
+raw_value(proper_list, [a, b, c]).
+raw_value(improper_list, [a, b | tail]).
+value(K, V) :- raw_value(K, V).

package/test/eyelang/conformance/cases/003_terms_and_readback.query

@@ -0,0 +1 @@
+value(K, V)

package/test/eyelang/conformance/cases/004_conjunction_and_parentheses.pl

@@ -0,0 +1,5 @@
+% Reference 5.5, 7: parenthesized comma terms are conjunctions in goal position.
+p(a).
+q(a).
+ok(X, yes) :- (p(X), q(X)).
+materialize(ok, 2).

package/test/eyelang/conformance/cases/004_conjunction_and_parentheses.query

@@ -0,0 +1 @@
+ok(X, Y)

package/test/eyelang/conformance/cases/005_list_deconstruction.pl

@@ -0,0 +1,6 @@
+% Reference 5.4, 12.1: list syntax and unification in rule heads.
+first([X | _Rest], X).
+tail([_Head | Tail], Tail).
+answer(first, X) :- first([a, b, c], X).
+answer(tail, Tail) :- tail([a, b, c], Tail).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/005_list_deconstruction.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/006_comma_formula_data.pl

@@ -0,0 +1,4 @@
+% Reference 5.5: comma terms remain data outside goal position.
+record((name(alice, "Alice"), knows(alice, bob))).
+answer(formula, F) :- record(F).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/006_comma_formula_data.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/007_anonymous_variables.pl

@@ -0,0 +1,5 @@
+% Reference 3.4, 5.1, 7.1: each anonymous variable occurrence is fresh.
+pair(a, one).
+pair(b, two).
+answer(fresh, yes) :- pair(a, _), pair(b, _).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/007_anonymous_variables.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/008_graphic_atoms.pl

@@ -0,0 +1,6 @@
+% Reference 3.5, 5.2, 11: graphic atom constants are scalar terms.
+materialize(value, 2).
+raw_value(hash, #).
+raw_value(arrow, =>).
+raw_value(comparison, =<).
+value(K, V) :- raw_value(K, V).

package/test/eyelang/conformance/cases/008_graphic_atoms.query

@@ -0,0 +1 @@
+value(K, V)

package/test/eyelang/conformance/cases/009_comments_and_whitespace.pl

@@ -0,0 +1,5 @@
+% Reference 3.2, 3.6: comments are ignored outside quoted text and atoms.
+  item(quoted_percent, "% not a comment").    % trailing comment
+item(quoted_atom, 'has % sign').
+answer(K, V) :- item(K, V).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/009_comments_and_whitespace.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/010_variable_scope_and_reuse.pl

@@ -0,0 +1,8 @@
+% Reference 5.1, 7.1: variable occurrences are scoped per clause and reused within a clause.
+edge(a, b).
+edge(b, c).
+edge(c, d).
+two_step(X, Z) :- edge(X, Y), edge(Y, Z).
+answer(from_a, Z) :- two_step(a, Z).
+answer(from_b, Z) :- two_step(b, Z).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/010_variable_scope_and_reuse.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/011_predicate_arity.pl

@@ -0,0 +1,6 @@
+% Reference 6: predicate name and arity both identify a predicate group.
+p(a).
+p(a, b).
+answer(unary, X) :- p(X).
+answer(binary, pair(X, Y)) :- p(X, Y).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/011_predicate_arity.query

@@ -0,0 +1 @@
+answer(K, V)