eyeling 1.33.0 → 1.33.1

package/README.md

@@ -791,7 +791,7 @@ Eyeling provides datatype built-ins in the namespace `https://eyereasoner.github
 
 Supported operations include:
 
-- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection;
+- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection. `dt:datatype` returns the literal's actual datatype IRI only, so RDF string literals return `xsd:string`; it does not return `rdfs:Literal`, which is a class of literals rather than a datatype IRI;
 - `dt:validForDatatype` and `dt:invalidForDatatype` for lexical validity and datatype membership checks, either as `?literal dt:validForDatatype ?datatype` tests or as tuple-to-boolean checks like `(?literal ?datatype) dt:validForDatatype true`;
 - `dt:sameValueAs` and `dt:differentValueFrom` for value-space equality and inequality;
 - `dt:canonicalLiteral` for canonical literal production.

package/dist/browser/eyeling.browser.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') {

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') {

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/package.json

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

package/test/builtins.test.js

@@ -199,7 +199,6 @@ const cases = [
 { "11"^^xsd:integer dt:differentValueFrom "12"^^xsd:integer . } => { :different :numeric true } .
 { "hello@en"^^rdf:PlainLiteral dt:differentValueFrom "bye@en"^^rdf:PlainLiteral . } => { :different :plainLiteral true } .
 { "a" dt:differentValueFrom "b" . } => { :different :string true } .
-{ "a" dt:datatype ?sd . ?sd <http://www.w3.org/2000/10/swap/log#notEqualTo> xsd:string . } => { :string :comparisonDatatype ?sd } .
 { "<a/>"^^rdf:XMLLiteral dt:differentValueFrom "<b/>"^^rdf:XMLLiteral . } => { :different :xmlLiteral true } .
 
 { ("1"^^xsd:integer xsd:integer) dt:validForDatatype true . } => { :tuple :valid true } .
@@ -252,7 +251,6 @@ const cases = [
       assert.match(out, /:different :numeric true \./);
       assert.match(out, /:different :plainLiteral true \./);
       assert.match(out, /:different :string true \./);
-      assert.match(out, /:string :comparisonDatatype rdfs:Literal \./);
       assert.match(out, /:different :xmlLiteral true \./);
       assert.match(out, /:tuple :valid true \./);
       assert.match(out, /:tuple :invalidBoolean true \./);
@@ -265,6 +263,21 @@ const cases = [
       assert.match(out, /:canonical :dateTime "2026-06-10T12:00:00Z"\^\^xsd:dateTime \./);
       assert.match(out, /:canonical :midnightRollover "2027-01-01T00:00:00Z"\^\^xsd:dateTime \./);
       assert.match(out, /:sameAs :reflexive true \./);
+
+      const datatypeOut = runReason(`
+@prefix : <http://example.org/datatype-tests#> .
+@prefix dt: <https://eyereasoner.github.io/eyeling/datatype#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+:s :plainName "Alice" .
+:s :typedName "Alice"^^xsd:string .
+{ :s :plainName ?value . ?value dt:datatype ?datatype . } => { :plain :detectedDatatype ?datatype } .
+{ :s :typedName ?value . ?value dt:datatype ?datatype . } => { :typed :detectedDatatype ?datatype } .
+`);
+      assert.match(datatypeOut, /:plain :detectedDatatype xsd:string \./);
+      assert.match(datatypeOut, /:typed :detectedDatatype xsd:string \./);
+      assert.doesNotMatch(datatypeOut, /:plain :detectedDatatype rdfs:Literal \./);
+      assert.doesNotMatch(datatypeOut, /:typed :detectedDatatype rdfs:Literal \./);
     },
   },
   {