eyeling 1.5.27 → 1.5.29

package/README.md

@@ -9,8 +9,8 @@ A minimal [Notation3 (N3)](https://notation3.org/) reasoner in **JavaScript**.
 - a practical N3/Turtle superset (enough for lots of real rulesets)
 - supports forward (`=>`) + backward (`<=`) chaining over Horn-style rules
 - prints only newly derived forward facts, optionally preceded by compact proof comments
-- we never want to leak raw data, hence pass-only-new and backward rules for functions that work with raw data
-- and of course we also keep all reasoning in the browser
+- “pass-only-new” style output (we never want to leak raw input data; backward rules can act like “functions” over raw data)
+- works fully client-side (browser) and in Node.js
 
 ## Playground (in your browser)
 
@@ -75,14 +75,13 @@ ESM:
 
 ```js
 import eyeling from "eyeling";
-
 const output = eyeling.reason({ proofComments: false }, input);
 console.log(output);
 ```
 
 Note: the API currently shells out to the bundled `eyeling.js` CLI under the hood (simple + robust).
 
-### Testing
+## Testing
 
 From a repo checkout:
 
@@ -99,10 +98,10 @@ npm run test:package
 npm run test:packlist
 ```
 
-- `test:api` runs an independent JS API test suite (does not rely on `examples/`).
-- `test:examples` runs the examples in the `examples` directory and compares against the golden outputs in `examples/output`.
-- `test:package` does a “real consumer” smoke test: `npm pack` → install tarball into a temp project → run API + CLI + examples.
-- `test:packlist` sanity-checks what will be published in the npm tarball (and the CLI shebang/bin wiring).
+* `test:api` runs an independent JS API test suite (does not rely on `examples/`).
+* `test:examples` runs the examples in the `examples` directory and compares against the golden outputs in `examples/output`.
+* `test:package` does a “real consumer” smoke test: `npm pack` → install tarball into a temp project → run API + CLI + examples.
+* `test:packlist` sanity-checks what will be published in the npm tarball (and the CLI shebang/bin wiring).
 
 ### Run a single file
 
@@ -134,15 +133,6 @@ node eyeling.js --no-proof-comments examples/socrates.n3
 node eyeling.js -n examples/socrates.n3
 ```
 
-### Run all examples
-
-```bash
-npm run test:examples
-```
-
-This runs `eyeling.js` over each example and compares against the golden outputs in `examples/output`
-(works both in a git checkout and in an npm-installed package).
-
 ## What output do I get?
 
 For each newly derived triple, `eyeling` prints:
@@ -156,14 +146,14 @@ The proof comments are compact “local justifications” per derived triple (no
 
 ### Forward + backward chaining
 
-- **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
-- **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
+* **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
+* **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
 
 Forward rule premises are proved using:
 
-- ground facts (input + derived)
-- backward rules
-- built-ins
+* ground facts (input + derived)
+* backward rules
+* built-ins
 
 The CLI prints only newly derived forward facts.
 
@@ -182,24 +172,30 @@ The CLI prints only newly derived forward facts.
 
 Supported:
 
-- `@prefix` / `@base`
-- triples with `;` and `,`
-- variables `?x`
-- blank nodes:
-  - anonymous `[]`
-  - property lists `[ :p :o; :q :r ]`
-- collections `( ... )`
-- quoted formulas `{ ... }`
-- implications:
-  - forward rules `{ P } => { C } .`
-  - backward rules `{ H } <= { B } .`
-- datatyped literals with `^^`
-- `#` line comments
+* `@prefix` / `@base`
+* triples with `;` and `,`
+* variables `?x`
+* blank nodes:
+
+  * anonymous `[]`
+  * property lists `[ :p :o; :q :r ]`
+* collections `( ... )`
+* quoted formulas `{ ... }`
+* implications:
+
+  * forward rules `{ P } => { C } .`
+  * backward rules `{ H } <= { B } .`
+* datatyped literals with `^^`
+* language-tagged string literals: `"hello"@en`, `"colour"@en-GB`
+* long string literals: `"""..."""` (can contain newlines; can also carry a language tag)
+* inverted predicate sugar: `?x <- :p ?y` (swaps subject/object for that predicate)
+* resource paths (forward `!` and reverse `^`): `:joe!:hasAddress!:hasCity "Metropolis".`
+* `#` line comments
 
 Non-goals / current limits:
 
-- not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
-- proof output is local per derived triple (not a global exported proof tree)
+* not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
+* proof output is local per derived triple (not a global exported proof tree)
 
 ## Blank nodes and quantification (pragmatic N3/EYE-style)
 
@@ -217,12 +213,12 @@ Equal facts up to renaming of Skolem IDs are treated as duplicates and are not r
 
 Top level:
 
-- `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
-- `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
+* `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
+* `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
 
 During reasoning:
 
-- any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
+* any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
 
 ## Inference fuse — `{ ... } => false.`
 
@@ -241,12 +237,12 @@ As soon as the premise is provable, `eyeling` exits with status code `2`.
 
 `eyeling` implements a pragmatic subset of common N3 builtin families and evaluates them during backward goal proving:
 
-- **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
-- **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
-- **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
-- **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
-- **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
-- **time**: `time:localTime`
+* **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
+* **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
+* **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
+* **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:integerQuotient` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
+* **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
+* **time**: `time:localTime`
 
 ## License
 

package/examples/easter.n3

@@ -0,0 +1,78 @@
+# =====================================================================
+# Easter Date
+# Calculation of easter dates.
+# original copy at http://www.w3.org/2000/10/swap/test/easter/easter.n3
+# =====================================================================
+
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix prolog: <http://eulersharp.sourceforge.net/2003/03swap/prolog#>.
+@prefix : <http://www.agfa.com/w3c/euler/easterP#>.
+
+<> rdfs:comment """
+              Divide            by      Quotient  Remainder
+        ---------------------------------------------------
+                 y               19                   j
+                 y              100        k          h
+                 k                4        m          n
+               k + 8             25        p
+             k - p + 1            3        q
+        19j + k - m - q + 15     30                   r
+                 h                4        s          u
+        32 + 2n + 2s - r - u      7                   v
+           j + 11r + 22v        451        w
+         r + v - 7w + 114        31        x          z
+
+Here x is the number of the month ond 1 + z is the day of that
+month upon which Easter Sunday falls in the year y.
+""".
+
+2021 a :Year.
+2022 a :Year.
+2023 a :Year.
+2024 a :Year.
+2025 a :Year.
+2026 a :Year.
+2027 a :Year.
+2028 a :Year.
+2029 a :Year.
+2030 a :Year.
+2031 a :Year.
+2032 a :Year.
+2033 a :Year.
+2034 a :Year.
+2035 a :Year.
+2036 a :Year.
+2037 a :Year.
+2038 a :Year.
+2039 a :Year.
+2040 a :Year.
+2041 a :Year.
+2042 a :Year.
+2043 a :Year.
+2044 a :Year.
+2045 a :Year.
+2046 a :Year.
+2047 a :Year.
+2048 a :Year.
+2049 a :Year.
+2050 a :Year.
+
+{   ?Y a :Year.
+    (?Y 19) math:remainder ?J.
+    (?Y 100) math:integerQuotient ?K; math:remainder ?H.
+    (?K 4) math:integerQuotient ?M; math:remainder ?N.
+    ((?K 8)!math:sum 25) math:integerQuotient ?P.
+    (((?K ?P)!math:difference 1)!math:sum 3) math:integerQuotient ?Q.
+    ((((((19 ?J)!math:product ?K)!math:sum ?M)!math:difference ?Q)!math:difference 15)!math:sum 30) math:remainder ?R.
+    (?H 4) math:integerQuotient ?S; math:remainder ?U.
+    ((32 (2 ?N)!math:product (2 ?S)!math:product ?R!math:negation ?U!math:negation)!math:sum 7) math:remainder ?V.
+    ((?J (11 ?R)!math:product (22 ?V)!math:product)!math:sum 451) math:integerQuotient ?W.
+    ((?R ?V (7 ?W)!math:product!math:negation 114)!math:sum 31) math:integerQuotient ?X; math:remainder ?Z.
+    (?Z 1) math:sum ?DAY.
+} => {
+    (?DAY ?X) :easterFor ?Y.
+}.