eyeling 1.32.1 → 1.33.1

package/eyeling-builtins.ttl

@@ -45,7 +45,7 @@ ex:aliasOf a rdf:Property .
 # --- dt: datatype ---------------------------------------------------
 
 dt:datatype a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Extracts the datatype IRI of a literal. Plain RDF string literals return xsd:string; language-tagged strings return rdf:langString; shorthand numeric/boolean literals return their inferred XSD datatype." .
+  rdfs:comment "Extracts the datatype IRI of a literal. Plain RDF string literals return xsd:string; language-tagged strings return rdf:langString; shorthand numeric/boolean literals return their inferred XSD datatype. It returns the literal's actual datatype IRI only; rdfs:Literal is a class and is not returned by dt:datatype." .
 
 dt:lexicalForm a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Extracts the literal lexical form as an xsd:string/plain string value, preserving the original lexical spelling such as leading zeroes." .

package/eyeling.js

@@ -1888,17 +1888,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -6493,6 +6483,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
+      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/index.d.ts

@@ -80,6 +80,38 @@ export interface N3SourceListInput {
   scopeBlankNodes?: boolean;
 }
 
+export type EngineName = 'n3' | 'eyeling' | 'eyelang' | 'prolog' | 'horn';
+
+export type EyelangSource = string | { eyelang?: string; prolog?: string; text?: string; label?: string };
+
+export interface EyelangSourceListInput {
+  sources: EyelangSource[];
+}
+
+export interface EyelangStats {
+  [key: string]: number;
+}
+
+export interface EyelangRunOptions {
+  engine?: EngineName;
+  proof?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  stats?: boolean;
+  rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  args?: string[];
+  maxBuffer?: number;
+  [key: string]: unknown;
+}
+
+export interface EyelangRunResult {
+  stdout: string;
+  stats: EyelangStats;
+}
+
 export interface RdfJsReasonInput {
   n3?: string;
   quads?: Iterable<import('@rdfjs/types').Quad> | AsyncIterable<import('@rdfjs/types').Quad>;
@@ -112,10 +144,17 @@ export interface StoreOptions {
 }
 
 export interface ReasonOptions {
+  engine?: EngineName;
   proof?: boolean;
   proofComments?: boolean;
   noProofComments?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  stats?: boolean;
   rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
   args?: string[];
   maxBuffer?: number;
   builtinModules?: string | string[];
@@ -139,6 +178,7 @@ export interface BuiltinRegistrationContext {
 export type BuiltinHandler = (ctx: BuiltinRegistrationContext) => Array<Record<string, EyelingTerm>>;
 
 export interface ReasonStreamOptions {
+  engine?: EngineName;
   baseIri?: string | null;
   proof?: boolean;
   includeInputFactsInClosure?: boolean;
@@ -199,12 +239,18 @@ export class PersistentFactStore implements FactStore {
 
 export function reason(
   opts: ReasonOptions,
-  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput | EyelangSourceListInput,
 ): string;
+export function runAsync(
+  input: string,
+  opts: ReasonStreamOptions & { engine: 'eyelang' | 'prolog' | 'horn' },
+): Promise<EyelangRunResult>;
 export function runAsync(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-  opts?: ReasonStreamOptions,
+  opts?: ReasonStreamOptions & { engine?: 'n3' | 'eyeling' },
 ): Promise<ReasonStreamResult & { store?: FactStore }>;
+export function runEyelang(input: string, opts?: EyelangRunOptions): Promise<EyelangRunResult>;
+export function reasonEyelang(input: string, opts?: EyelangRunOptions): Promise<string>;
 export function reasonStream(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
   opts?: ReasonStreamOptions,
@@ -227,6 +273,8 @@ export interface EyelingModule {
   readonly version: string;
   reason: typeof reason;
   runAsync: typeof runAsync;
+  runEyelang: typeof runEyelang;
+  reasonEyelang: typeof reasonEyelang;
   reasonStream: typeof reasonStream;
   reasonRdfJs: typeof reasonRdfJs;
   readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;

package/index.js

@@ -4,12 +4,100 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const cp = require('node:child_process');
+const { pathToFileURL } = require('node:url');
 
 const bundleApi = require('./eyeling.js');
 const { dataFactory, normalizeReasonerInputSync } = require('./lib/rdfjs');
 const { isN3SourceListInput } = require('./lib/multisource');
 const engine = require('./lib/engine');
 
+
+function normalizeEngineName(value) {
+  if (value == null || value === '') return 'n3';
+  const name = String(value).toLowerCase();
+  if (name === 'n3' || name === 'eyeling') return 'n3';
+  if (name === 'eyelang' || name === 'prolog' || name === 'horn') return 'eyelang';
+  throw new TypeError(`unknown Eyeling engine: ${value}`);
+}
+
+function normalizeEyelangSourceForTempFile(source) {
+  if (typeof source === 'string') return source;
+  if (source && typeof source === 'object' && !Array.isArray(source)) {
+    const text =
+      typeof source.eyelang === 'string' ? source.eyelang
+        : typeof source.prolog === 'string' ? source.prolog
+          : typeof source.text === 'string' ? source.text
+            : typeof source.n3 === 'string' ? source.n3
+              : null;
+    if (text !== null) return text;
+  }
+  throw new TypeError('reason({ engine: "eyelang" }, input): each source must be a string or an object with an eyelang/prolog/text field');
+}
+
+function normalizeEyelangInput(input) {
+  if (typeof input === 'string') return [input];
+  if (input == null) return [''];
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    if (Array.isArray(input.sources)) return input.sources.map(normalizeEyelangSourceForTempFile);
+    return [normalizeEyelangSourceForTempFile(input)];
+  }
+  throw new TypeError('reason({ engine: "eyelang" }, input): input must be a string, source object, or { sources } list');
+}
+
+function reasonEyelangSync(opt = {}, input = '') {
+  const args = [];
+
+  if (opt.proof || opt.why || opt.explain) args.push('--proof');
+  if (opt.stats) args.push('--stats');
+  if (opt.rdf || opt.rdf12) args.push('--rdf');
+  if (opt.n3) args.push('--n3');
+  if (typeof opt.inputFormat === 'string' && opt.inputFormat) args.push('--input-format', opt.inputFormat);
+  if (Array.isArray(opt.args)) args.push(...opt.args);
+
+  const maxBuffer = Number.isFinite(opt.maxBuffer) ? opt.maxBuffer : 50 * 1024 * 1024;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-eyelang-'));
+
+  try {
+    const inputFiles = normalizeEyelangInput(input).map((text, index) => {
+      const inputFile = path.join(dir, `input-${index + 1}.pl`);
+      fs.writeFileSync(inputFile, text, 'utf8');
+      return inputFile;
+    });
+
+    const eyelangCliPath = path.join(__dirname, 'lib', 'eyelang', 'bin.js');
+    const res = cp.spawnSync(process.execPath, [eyelangCliPath, ...args, ...inputFiles], { encoding: 'utf8', maxBuffer });
+
+    if (res.error) throw res.error;
+    if (res.stderr) process.stderr.write(res.stderr);
+
+    if (res.status !== 0) {
+      const err = new Error(res.stderr || `eyelang exited with code ${res.status}`);
+      err.code = res.status;
+      err.stdout = res.stdout;
+      err.stderr = res.stderr;
+      throw err;
+    }
+
+    return res.stdout;
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+async function loadEyelangModule() {
+  return import(pathToFileURL(path.join(__dirname, 'lib', 'eyelang', 'index.mjs')).href);
+}
+
+async function runEyelang(input = '', opt = {}) {
+  const eyelang = await loadEyelangModule();
+  return eyelang.run(input, opt || {});
+}
+
+async function reasonEyelang(input = '', opt = {}) {
+  const result = await runEyelang(input, opt || {});
+  return result.stdout;
+}
+
 function reason(opt = {}, input = '') {
   if (input == null) input = '';
 
@@ -17,6 +105,8 @@ function reason(opt = {}, input = '') {
   if (Array.isArray(opt)) opt = { args: opt };
   if (opt == null || typeof opt !== 'object') opt = {};
 
+  if (normalizeEngineName(opt.engine) === 'eyelang') return reasonEyelangSync(opt, input);
+
   const args = [];
 
   // default: proof output OFF for API output (machine-friendly)
@@ -116,12 +206,16 @@ function reason(opt = {}, input = '') {
 }
 
 async function runAsync(input = '', opt = {}) {
-  return engine.runAsync(input, opt || {});
+  const options = opt || {};
+  if (normalizeEngineName(options.engine) === 'eyelang') return runEyelang(input, options);
+  return engine.runAsync(input, options);
 }
 
 module.exports = {
   reason,
   runAsync,
+  runEyelang,
+  reasonEyelang,
   reasonStream: bundleApi.reasonStream,
   reasonRdfJs: bundleApi.reasonRdfJs,
   rdfjs: dataFactory,

package/lib/builtins.js

@@ -1877,17 +1877,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {

package/lib/cli.js

@@ -805,6 +805,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
+      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/lib/eyelang/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+import('./cli.mjs').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+  console.error(`eyelang: ${error && error.message ? error.message : String(error)}`);
+  process.exit(1);
+});

package/lib/eyelang/builtins/aggregation.mjs

@@ -0,0 +1,81 @@
+// Aggregation builtins that run a inner goal and collect, count, sum, or select the best answers.
+// Each handler clones the solver so the inner goal can enumerate independently of the outer goal.
+import { compareTerms, copyResolved, isDecimalInteger, lexicalValue, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.mjs';
+
+export const aggregationBuiltins = {
+  register(registry) {
+    registry.add('findall', 3, findall);
+    registry.add('countall', 2, countall);
+    registry.add('sumall', 3, sumall);
+    registry.add('aggregate_min', 5, aggregateBest(true));
+    registry.add('aggregate_max', 5, aggregateBest(false));
+  }
+};
+
+function* findall({ solver, goal, env }) {
+  const [template, innerGoal, bag] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  const collected = [];
+  for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) collected.push(copyResolved(template, answerEnv));
+  const next = env.clone();
+  if (unify(bag, listFromItems(collected), next)) yield next;
+}
+
+function* countall({ solver, goal, env }) {
+  const [innerGoal, count] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  let n = 0;
+  for (const _ of collector.solve([innerGoal], env.clone(), 0)) n++;
+  const next = env.clone();
+  if (unify(count, numberTerm(n), next)) yield next;
+}
+
+function* sumall({ solver, goal, env }) {
+  const [template, innerGoal, sum] = goal.args;
+  const collector = solver.cloneForInnerGoal(10000000);
+  let intSum = 0n;
+  let floatMode = false;
+  let floatSum = 0;
+  for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) {
+    const text = lexicalValue(template, answerEnv);
+    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 result = floatMode ? numberTextFromDouble(floatSum) : intSum.toString();
+  const next = env.clone();
+  if (unify(sum, numberTerm(result), next)) yield next;
+}
+
+function aggregateBest(wantMin) {
+  return function* ({ solver, goal, env }) {
+    const [keyTemplate, valueTemplate, innerGoal, bestKey, bestValue] = goal.args;
+    const collector = solver.cloneForInnerGoal(10000000);
+    let has = false;
+    let key = null;
+    let value = null;
+    for (const answerEnv of collector.solve([innerGoal], env.clone(), 0)) {
+      const candidateKey = copyResolved(keyTemplate, answerEnv);
+      const candidateValue = copyResolved(valueTemplate, answerEnv);
+      if (!has) {
+        has = true;
+        key = candidateKey;
+        value = candidateValue;
+      } else {
+        const cmp = compareTerms(candidateKey, key);
+        if ((wantMin && cmp < 0) || (!wantMin && cmp > 0)) {
+          key = candidateKey;
+          value = candidateValue;
+        }
+      }
+    }
+    if (!has) return;
+    const next = env.clone();
+    if (unify(bestKey, key, next) && unify(bestValue, value, next)) yield next;
+  };
+}

package/lib/eyelang/builtins/alphametic.mjs

@@ -0,0 +1,144 @@
+// Reusable alphametic addition solver.
+// It evaluates column constraints right-to-left, so examples such as
+// SEND+MORE=MONEY and DONALD+GERALD=ROBERT do not need to express digit search
+// with many relational select/3 and arithmetic goals.
+import { atom, deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+
+export const alphameticBuiltins = {
+  register(registry) {
+    registry.add('alphametic_sum', 5, alphameticSum, {
+      fallbackWhenNotReady: true,
+      ready: alphameticReady,
+    });
+  }
+};
+
+function alphameticReady(goal, env) {
+  return atomList(goal.args[0], env) !== null && wordList(goal.args[1], env) !== null && atomList(goal.args[2], env) !== null;
+}
+
+function* alphameticSum({ goal, env }) {
+  const letters = atomList(goal.args[0], env);
+  const addends = wordList(goal.args[1], env);
+  const result = atomList(goal.args[2], env);
+  if (!letters || !addends || !result || letters.length > 10 || addends.length === 0) return;
+
+  const letterSet = new Set(letters);
+  for (const word of [...addends, result]) for (const letter of word) if (!letterSet.has(letter)) return;
+
+  const leading = new Set();
+  for (const word of [...addends, result]) if (word.length > 1) leading.add(word[0]);
+  const maxLen = Math.max(result.length, ...addends.map((word) => word.length));
+  const assignment = new Map();
+  const used = Array(10).fill(false);
+
+  function canUse(letter, digit) {
+    return !used[digit] && !(digit === 0 && leading.has(letter));
+  }
+
+  function assignDigit(letter, digit) {
+    assignment.set(letter, digit);
+    used[digit] = true;
+  }
+
+  function unassignDigit(letter, digit) {
+    assignment.delete(letter);
+    used[digit] = false;
+  }
+
+  function* assignAddends(column, carry, index, sum) {
+    if (index >= addends.length) {
+      yield* finishColumn(column, sum);
+      return;
+    }
+    const word = addends[index];
+    const letter = word[word.length - 1 - column];
+    if (letter === undefined) {
+      yield* assignAddends(column, carry, index + 1, sum);
+      return;
+    }
+    const assigned = assignment.get(letter);
+    if (assigned !== undefined) {
+      yield* assignAddends(column, carry, index + 1, sum + assigned);
+      return;
+    }
+    for (let digit = 0; digit <= 9; digit++) {
+      if (!canUse(letter, digit)) continue;
+      assignDigit(letter, digit);
+      yield* assignAddends(column, carry, index + 1, sum + digit);
+      unassignDigit(letter, digit);
+    }
+  }
+
+  function* finishColumn(column, sum) {
+    const resultLetter = result[result.length - 1 - column];
+    const digit = sum % 10;
+    const nextCarry = Math.floor(sum / 10);
+    if (resultLetter === undefined) {
+      if (digit === 0) yield* solveColumn(column + 1, nextCarry);
+      return;
+    }
+    const assigned = assignment.get(resultLetter);
+    if (assigned !== undefined) {
+      if (assigned === digit) yield* solveColumn(column + 1, nextCarry);
+      return;
+    }
+    if (!canUse(resultLetter, digit)) return;
+    assignDigit(resultLetter, digit);
+    yield* solveColumn(column + 1, nextCarry);
+    unassignDigit(resultLetter, digit);
+  }
+
+  function* solveColumn(column, carry) {
+    if (column >= maxLen) {
+      if (carry !== 0) return;
+      if (assignment.size !== letters.length) return;
+      yield new Map(assignment);
+      return;
+    }
+    yield* assignAddends(column, carry, 0, carry);
+  }
+
+  for (const solution of solveColumn(0, 0)) {
+    const digitTerms = letters.map((letter) => numberTerm(String(solution.get(letter))));
+    const values = [...addends, result].map((word) => wordValue(word, solution));
+    const valueTerms = values.map((value) => numberTerm(String(value)));
+    const next = env.clone();
+    if (unify(goal.args[3], listFromItems(digitTerms), next) && unify(goal.args[4], listFromItems(valueTerms), next)) yield next;
+  }
+}
+
+function wordValue(word, assignment) {
+  let value = 0;
+  for (const letter of word) value = value * 10 + assignment.get(letter);
+  return value;
+}
+
+function atomList(term, env) {
+  const items = properListItems(term, env);
+  if (!items) return null;
+  const out = [];
+  for (const item of items) {
+    const text = atomKey(deref(item, env));
+    if (text == null) return null;
+    out.push(text);
+  }
+  return out;
+}
+
+function wordList(term, env) {
+  const items = properListItems(term, env);
+  if (!items) return null;
+  const out = [];
+  for (const item of items) {
+    const word = atomList(item, env);
+    if (!word) return null;
+    out.push(word);
+  }
+  return out;
+}
+
+function atomKey(term) {
+  if (term.type === 'atom' || term.type === 'string' || term.type === 'number') return term.name;
+  return null;
+}