eyeling 1.24.4 → 1.24.6

package/lib/lexer.js

@@ -355,6 +355,7 @@ function stripQuotes(lex) {
 //   - A top-level default graph block { ... } is unwrapped into ordinary triples.
 // This keeps all downstream parsing/reasoning N3-only.
 const LOG_NAME_OF_IRI = '<http://www.w3.org/2000/10/swap/log#nameOf>';
+const RDF_REIFIES_IRI = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies>';
 
 function normalizeRdfCompatibility(inputText) {
   let text = String(inputText ?? '');
@@ -363,11 +364,12 @@ function normalizeRdfCompatibility(inputText) {
   // surface-syntax normalization. Avoid scanning large files character-by-character
   // unless they actually contain RDF 1.2 triple terms, VERSION directives, or a
   // plausible top-level TriG named graph block.
-  const hasTripleTerms = text.includes('<<(');
+  const hasTripleTerms = text.includes('<<');
   const hasVersionDirective = /^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/im.test(text);
   const hasNamedGraphCandidate = /(?:^|[.\r\n])\s*(?:GRAPH\s+)?(?:<[^>\r\n]*>|_:[A-Za-z][A-Za-z0-9_-]*|[A-Za-z][A-Za-z0-9_-]*:[^\s{};,.()[\]]*)\s*\{/m.test(text);
+  const hasAnnotationSyntax = /(?:^|\s)~\s*(?:<|_:[A-Za-z]|[A-Za-z][A-Za-z0-9_-]*:|\{\|)|\{\|/.test(text);
 
-  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate) return text;
+  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate && !hasAnnotationSyntax) return text;
 
   function isWordChar(ch) {
     return ch != null && /[A-Za-z0-9_:-]/.test(ch);
@@ -429,11 +431,67 @@ function normalizeRdfCompatibility(inputText) {
 
   function convertTripleTerms(s) {
     let i = 0;
+    const reifierTriples = [];
 
     function startsAt(needle, at = i) {
       return s.startsWith(needle, at);
     }
 
+    function splitTopLevelReifier(body) {
+      let depthBrace = 0;
+      let depthBracket = 0;
+      let depthParen = 0;
+      for (let j = 0; j < body.length; j++) {
+        const ch = body[j];
+        if (ch === '"' || ch === "'") {
+          const str = readStringAt(body, j);
+          j = str.end - 1;
+          continue;
+        }
+        if (ch === '<') {
+          const iri = readIriAt(body, j);
+          j = iri.end - 1;
+          continue;
+        }
+        if (ch === '#') {
+          while (j < body.length && body[j] !== '\n' && body[j] !== '\r') j += 1;
+          continue;
+        }
+        if (ch === '{') depthBrace += 1;
+        else if (ch === '}' && depthBrace > 0) depthBrace -= 1;
+        else if (ch === '[') depthBracket += 1;
+        else if (ch === ']' && depthBracket > 0) depthBracket -= 1;
+        else if (ch === '(') depthParen += 1;
+        else if (ch === ')' && depthParen > 0) depthParen -= 1;
+        else if (ch === '~' && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+          return { triple: body.slice(0, j).trim(), reifier: body.slice(j + 1).trim() };
+        }
+      }
+      return { triple: body.trim(), reifier: '' };
+    }
+
+    function firstTerm(text) {
+      const at = skipWsAndComments(text, 0);
+      if (at >= text.length) return '';
+      if (text[at] === '<') return readIriAt(text, at).text;
+      let j = at;
+      while (j < text.length && !/\s/.test(text[j]) && !'{}[](),;.'.includes(text[j])) j += 1;
+      return text.slice(at, j);
+    }
+
+    function graphTermFromTripleBody(rawBody, parenthesized) {
+      let body = rawBody.trim();
+      if (parenthesized && body.startsWith('(') && body.endsWith(')')) body = body.slice(1, -1).trim();
+      const split = splitTopLevelReifier(body);
+      const triple = split.triple;
+      const graph = '{ ' + triple + ' }';
+      if (split.reifier) {
+        const reifier = firstTerm(split.reifier);
+        if (reifier) reifierTriples.push(`${reifier} ${RDF_REIFIES_IRI} ${graph} .`);
+      }
+      return graph;
+    }
+
     function convertUntil(stopToken) {
       let out = '';
       while (i < s.length) {
@@ -443,7 +501,12 @@ function normalizeRdfCompatibility(inputText) {
         }
         if (startsAt('<<(')) {
           i += 3;
-          out += '{ ' + convertUntil(')>>').trim() + ' }';
+          out += graphTermFromTripleBody(convertUntil(')>>'), false);
+          continue;
+        }
+        if (startsAt('<<')) {
+          i += 2;
+          out += graphTermFromTripleBody(convertUntil('>>'), false);
           continue;
         }
         const ch = s[i];
@@ -474,7 +537,189 @@ function normalizeRdfCompatibility(inputText) {
       return out;
     }
 
-    return convertUntil(null);
+    const converted = convertUntil(null);
+    if (reifierTriples.length === 0) return converted;
+    return converted + (converted.endsWith('\n') ? '' : '\n') + reifierTriples.join('\n') + '\n';
+  }
+
+
+  function convertAnnotations(s) {
+    let out = '';
+    let i = 0;
+    let statementStart = true;
+    let generatedBlank = 0;
+
+    function readBalancedDelimited(s, at, open, close) {
+      if (!s.startsWith(open, at)) return null;
+      let j = at + open.length;
+      let depth = 1;
+      while (j < s.length) {
+        const ch = s[j];
+        if (ch === '"' || ch === "'") {
+          j = readStringAt(s, j).end;
+          continue;
+        }
+        if (ch === '<' && !s.startsWith('<<', j)) {
+          j = readIriAt(s, j).end;
+          continue;
+        }
+        if (ch === '#') {
+          while (j < s.length && s[j] !== '\n' && s[j] !== '\r') j += 1;
+          continue;
+        }
+        if (s.startsWith(open, j)) {
+          depth += 1;
+          j += open.length;
+          continue;
+        }
+        if (s.startsWith(close, j)) {
+          depth -= 1;
+          j += close.length;
+          if (depth === 0) return { text: s.slice(at, j), inner: s.slice(at + open.length, j - close.length), end: j };
+          continue;
+        }
+        j += 1;
+      }
+      throw new N3SyntaxError(`Unterminated RDF annotation block, expected ${close}`);
+    }
+
+    function readTermLikeAt(s, at) {
+      const j = skipWsAndComments(s, at);
+      if (j >= s.length) return null;
+      if (s[j] === '<') return readIriAt(s, j);
+      if (s[j] === '"' || s[j] === "'") {
+        const str = readStringAt(s, j);
+        let end = str.end;
+        let text = str.text;
+        if (s.startsWith('^^', end)) {
+          const dt = readTermAt(s, end + 2);
+          if (dt) {
+            text += '^^' + dt.text;
+            end = dt.end;
+          }
+        } else if (s[end] === '@') {
+          let k = end + 1;
+          if (/[A-Za-z]/.test(s[k] || '')) {
+            while (k < s.length && /[A-Za-z0-9-]/.test(s[k])) k += 1;
+            text += s.slice(end, k);
+            end = k;
+          }
+        }
+        return { text, end };
+      }
+      if (s[j] === '{') return readBalancedBlock(s, j);
+      if (s[j] === '[') return readBalancedDelimited(s, j, '[', ']');
+      if (s[j] === '(') return readBalancedDelimited(s, j, '(', ')');
+      return readTermAt(s, j);
+    }
+
+    function readAnnotationBlockAt(s, at) {
+      if (!s.startsWith('{|', at)) return null;
+      return readBalancedDelimited(s, at, '{|', '|}');
+    }
+
+    function tryReadAnnotatedTriple(at) {
+      const start = skipWsAndComments(s, at);
+      if (start >= s.length) return null;
+      if (s[start] === '@') return null;
+      if (startsWordAt(s, 'PREFIX', start) || startsWordAt(s, 'BASE', start) || startsWordAt(s, 'VERSION', start)) return null;
+      if (startsWordAt(s, 'GRAPH', start)) return null;
+
+      const subj = readTermLikeAt(s, start);
+      if (!subj) return null;
+      let j = skipWsAndComments(s, subj.end);
+      const pred = readTermLikeAt(s, j);
+      if (!pred) return null;
+      j = skipWsAndComments(s, pred.end);
+      const obj = readTermLikeAt(s, j);
+      if (!obj) return null;
+      j = skipWsAndComments(s, obj.end);
+      if (s[j] !== '~' && !s.startsWith('{|', j)) return null;
+
+      let reifier = '';
+      const annotationBlocks = [];
+      while (j < s.length) {
+        j = skipWsAndComments(s, j);
+        if (s[j] === '~') {
+          j += 1;
+          j = skipWsAndComments(s, j);
+          const term = readTermAt(s, j);
+          if (term) {
+            reifier = term.text;
+            j = term.end;
+          } else if (!reifier) {
+            reifier = `_:rdfAnnotation${++generatedBlank}`;
+          }
+          continue;
+        }
+        if (s.startsWith('{|', j)) {
+          const block = readAnnotationBlockAt(s, j);
+          if (!reifier) reifier = `_:rdfAnnotation${++generatedBlank}`;
+          annotationBlocks.push(block.inner.trim());
+          j = block.end;
+          continue;
+        }
+        break;
+      }
+
+      const after = skipWsAndComments(s, j);
+      if (s[after] !== '.') return null;
+      if (!reifier && annotationBlocks.length === 0) return null;
+
+      const baseTriple = `${subj.text} ${pred.text} ${obj.text}`;
+      const graph = `{ ${baseTriple} }`;
+      const extra = [];
+      if (reifier) extra.push(`${reifier} ${RDF_REIFIES_IRI} ${graph} .`);
+      for (const inner of annotationBlocks) {
+        if (inner) extra.push(`${reifier} ${inner} .`);
+      }
+      return {
+        start,
+        end: after + 1,
+        text: `${baseTriple} .${extra.length ? '\n' + extra.join('\n') : ''}`,
+      };
+    }
+
+    while (i < s.length) {
+      if (statementStart) {
+        const converted = tryReadAnnotatedTriple(i);
+        if (converted) {
+          out += s.slice(i, converted.start) + converted.text;
+          i = converted.end;
+          statementStart = true;
+          continue;
+        }
+      }
+
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        const str = readStringAt(s, i);
+        out += str.text;
+        i = str.end;
+        continue;
+      }
+      if (ch === '<' && !s.startsWith('<<', i)) {
+        const iri = readIriAt(s, i);
+        out += iri.text;
+        i = iri.end;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length) {
+          const c = s[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        statementStart = true;
+        continue;
+      }
+      out += ch;
+      if (ch === '.' || ch === '{' || ch === '}' || ch === '\n' || ch === '\r') statementStart = true;
+      else if (!/\s/.test(ch)) statementStart = false;
+      i += 1;
+    }
+
+    return out;
   }
 
   function stripVersionDirectives(s) {
@@ -633,6 +878,7 @@ function normalizeRdfCompatibility(inputText) {
   }
 
   if (hasTripleTerms) text = convertTripleTerms(text);
+  if (hasAnnotationSyntax) text = convertAnnotations(text);
   if (hasVersionDirective) text = stripVersionDirectives(text);
   if (hasVersionDirective || hasNamedGraphCandidate) text = normalizeNamedGraphs(text);
   return text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.24.4",
+  "version": "1.24.6",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -31,26 +31,23 @@
     "lib",
     "test",
     "tools",
-    "examples",
-    "see"
+    "examples"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
     "prebuild": "eslint . --fix",
-    "generate": "set -e; for f in see/examples/n3/*.n3; do ./see/see.js generate \"$f\" --force; done",
-    "build": "npm run generate && node tools/bundle.js",
+    "build": "node tools/bundle.js",
     "test:packlist": "node test/packlist.test.js",
     "test:api": "node test/api.test.js",
     "test:builtins": "node test/builtins.test.js",
     "test:examples": "node test/examples.test.js",
-    "test:see": "node test/see.test.js",
     "test:manifest": "node test/manifest.test.js",
     "test:playground": "node test/playground.test.js",
     "test:package": "node test/package.test.js",
     "pretest": "npm run build && npm run test:packlist",
-    "test": "npm run test:api && npm run test:builtins && npm run test:examples && npm run test:see && npm run test:manifest && npm run test:playground",
+    "test": "npm run test:api && npm run test:builtins && npm run test:examples && npm run test:manifest && npm run test:playground",
     "posttest": "npm run test:package",
     "preversion": "npm test",
     "postversion": "git push origin HEAD --follow-tags"

package/test/api.test.js

@@ -81,6 +81,14 @@ function fail(msg) {
   console.error(`${C.r}FAIL${C.n} ${msg}`);
 }
 
+function unnumberedName(name) {
+  return String(name).replace(/^\d+[a-z]*\s+/i, '');
+}
+
+function numberedName(index, name) {
+  return `${String(index + 1).padStart(3, '0')} ${unnumberedName(name)}`;
+}
+
 function msNow() {
   return Date.now();
 }
@@ -2572,6 +2580,46 @@ _:b a ex:Person ; ex:name "B" .
     expect: [/:observation\s+:entails\s+<<\(\s+:sensor\s+:needs\s+:inspection\s*\)>>\s*\./m],
   },
 
+  {
+    name: 'RDF mode accepts PREFIX and reified triple terms with reifiers',
+    opt: { proofComments: false, rdf: true },
+    input: `VERSION "1.2"
+
+PREFIX : <http://www.example.org/>
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+<<:employee38 :jobTitle "Assistant Designer" ~ _:id>> :accordingTo :employee22 .
+
+{ ?S ?P ?O } log:query { ?S ?P ?O } .
+`,
+    expect: [
+      /<<\(\s*:employee38\s+:jobTitle\s+"Assistant Designer"\s*\)>>\s+:accordingTo\s+:employee22\s*\./m,
+      /_:id\s+(?:rdf:reifies|<http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#reifies>)\s+<<\(\s*:employee38\s+:jobTitle\s+"Assistant Designer"\s*\)>>\s*\./m,
+    ],
+  },
+
+  {
+    name: 'RDF mode accepts RDF 1.2 annotation syntax after objects',
+    opt: { proofComments: false, rdf: true },
+    input: `VERSION "1.2"
+
+PREFIX : <http://example.com/>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+
+:a :name "Alice" ~ :t {| :statedBy :bob ; :recorded "2021-07-07"^^xsd:date |} .
+
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+
+{ ?S ?P ?O } log:query { ?S ?P ?O }.
+`,
+    expect: [
+      /:a\s+:name\s+"Alice"\s*\./m,
+      /:t\s+(?:rdf:reifies|<http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#reifies>)\s+<<\(\s*:a\s+:name\s+"Alice"\s*\)>>\s*\./m,
+      /:t\s+:statedBy\s+:bob\s*\./m,
+      /:t\s+:recorded\s+"2021-07-07"\^\^xsd:date\s*\./m,
+    ],
+  },
+
   {
     name: 'RDF mode serializes only valid triple terms as RDF 1.2 triple terms',
     opt: { proofComments: false, rdf: true },
@@ -2624,6 +2672,14 @@ _:b a ex:Person ; ex:name "B" .
       /:audit\s+\{[\s\S]*:workOrder\s+:basedOn\s+:factoryDataset\s*\.[\s\S]*\}/m,
     ],
   },
+  {
+    name: 'API empty input returns empty output',
+    opt: { proofComments: false },
+    input: '',
+    check(out) {
+      assert.equal(out, '');
+    },
+  },
 ];
 
 
@@ -2634,7 +2690,8 @@ let failed = 0;
   const suiteStart = Date.now();
   info(`Running ${cases.length} API tests (independent of examples/)`);
 
-  for (const tc of cases) {
+  for (const [index, tc] of cases.entries()) {
+    const testName = numberedName(index, tc.name);
     const start = msNow();
     try {
       const out = typeof tc.run === 'function' ? await tc.run() : reasonQuiet(tc.opt, tc.input);
@@ -2643,24 +2700,24 @@ let failed = 0;
         throw new Error(`Expected an error, but reason() returned output:\n${out}`);
       }
 
-      for (const re of tc.expect || []) mustMatch(out, re, `${tc.name}: missing expected pattern ${re}`);
-      for (const re of tc.notExpect || []) mustNotMatch(out, re, `${tc.name}: unexpected pattern ${re}`);
+      for (const re of tc.expect || []) mustMatch(out, re, `${testName}: missing expected pattern ${re}`);
+      for (const re of tc.notExpect || []) mustNotMatch(out, re, `${testName}: unexpected pattern ${re}`);
 
       if (typeof tc.check === 'function') tc.check(out, tc);
 
       const dur = msNow() - start;
-      ok(`${tc.name} ${C.dim}(${dur} ms)${C.n}`);
+      ok(`${testName} ${C.dim}(${dur} ms)${C.n}`);
       passed++;
     } catch (e) {
       const dur = msNow() - start;
 
       if (tc.expectErrorCode != null) {
         if (e && typeof e === 'object' && 'code' in e && e.code === tc.expectErrorCode) {
-          ok(`${tc.name} ${C.dim}(expected exit ${tc.expectErrorCode}, ${dur} ms)${C.n}`);
+          ok(`${testName} ${C.dim}(expected exit ${tc.expectErrorCode}, ${dur} ms)${C.n}`);
           passed++;
           continue;
         }
-        fail(`${tc.name} ${C.dim}(${dur} ms)${C.n}`);
+        fail(`${testName} ${C.dim}(${dur} ms)${C.n}`);
         fail(
           `Expected exit code ${tc.expectErrorCode}, got: ${e && e.code != null ? e.code : 'unknown'}\n${
             e && e.stderr ? e.stderr : e && e.stack ? e.stack : String(e)
@@ -2671,12 +2728,12 @@ let failed = 0;
       }
 
       if (tc.expectError) {
-        ok(`${tc.name} ${C.dim}(expected error, ${dur} ms)${C.n}`);
+        ok(`${testName} ${C.dim}(expected error, ${dur} ms)${C.n}`);
         passed++;
         continue;
       }
 
-      fail(`${tc.name} ${C.dim}(${dur} ms)${C.n}`);
+      fail(`${testName} ${C.dim}(${dur} ms)${C.n}`);
       fail(e && e.stack ? e.stack : String(e));
       failed++;
     }

package/test/examples.test.js

@@ -96,6 +96,14 @@ function resolveExpectedPath(outputDir, inputFile) {
   return path.join(outputDir, candidates[0]);
 }
 
+function resolveExampleTrigInput(root, inputFile) {
+  const stem = path.basename(inputFile, path.extname(inputFile));
+  const rel = path.join('input', `${stem}.trig`);
+  const abs = path.join(root, 'examples', rel);
+  if (!fs.existsSync(abs)) return null;
+  return { abs, rel };
+}
+
 function resolveExampleBuiltinPath(root, inputFile) {
   const stem = path.basename(inputFile, path.extname(inputFile));
   const rel = path.join('examples', 'builtin', `${stem}.js`);
@@ -182,19 +190,31 @@ function main() {
     // load it for the matching examples/<stem>.n3 file. Builtin-backed examples
     // run from the repository root so the command shape matches documented usage:
     //   node eyeling.js --builtin examples/builtin/foo.js examples/foo.n3
+    // A matching examples/input/<stem>.trig sidecar is external RDF/TriG
+    // evidence for this example, so include it and run in -r mode automatically.
     const builtin = resolveExampleBuiltinPath(root, file);
+    const trigInput = resolveExampleTrigInput(root, file);
+    const rdfMode = !!trigInput;
     const outFd = fs.openSync(generatedPath, 'w');
     let r;
     try {
       if (builtin) {
-        r = cp.spawnSync(nodePath, [eyelingJsPath, '-d', '--builtin', builtin.rel, path.join('examples', file)], {
+        const args = [eyelingJsPath, '-d'];
+        if (rdfMode) args.push('-r');
+        args.push('--builtin', builtin.rel, path.join('examples', file));
+        if (trigInput) args.push(path.join('examples', trigInput.rel));
+        r = cp.spawnSync(nodePath, args, {
           cwd: root,
           stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
           maxBuffer: 200 * 1024 * 1024,
           encoding: 'utf8',
         });
       } else {
-        r = cp.spawnSync(nodePath, [eyelingJsPath, '-d', file], {
+        const args = [eyelingJsPath, '-d'];
+        if (rdfMode) args.push('-r');
+        args.push(file);
+        if (trigInput) args.push(trigInput.rel);
+        r = cp.spawnSync(nodePath, args, {
           cwd: examplesDir,
           stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
           maxBuffer: 200 * 1024 * 1024,

package/test/package.test.js

@@ -73,6 +73,14 @@ function expectedExitCode(n3Text) {
   return 0;
 }
 
+function resolveExampleTrigInput(examplesDir, inputFile) {
+  const stem = path.basename(inputFile, path.extname(inputFile));
+  const rel = path.join('input', `${stem}.trig`);
+  const abs = path.join(examplesDir, rel);
+  if (!fs.existsSync(abs)) return null;
+  return { abs, rel };
+}
+
 function hasGit() {
   const r = run('git', ['--version']);
   return r.status === 0;
@@ -174,7 +182,7 @@ function main() {
     if (!fs.existsSync(eyelingJsPath)) throw new Error(`Missing eyeling.js in installed package: ${eyelingJsPath}`);
 
     // Keep this fast: package.test.js is a smoke test. The full matrix is covered by test/examples.test.js in-repo.
-    const SMOKE_EXAMPLES = ['age.n3', 'basic-monadic.n3', 'collection.n3', 'family-cousins.n3', 'backward.n3'];
+    const SMOKE_EXAMPLES = ['age.n3', 'basic-monadic.n3', 'family-cousins.n3', 'backward.n3', 'context-association.n3'];
 
     const tmpExamplesOut = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-pkg-examples-'));
     let smokeIdx = 1;
@@ -192,7 +200,13 @@ function main() {
         const n3Text = fs.readFileSync(inputPath, 'utf8');
         const expectedRc = expectedExitCode(n3Text);
 
-        const r = cp.spawnSync(process.execPath, [eyelingJsPath, '-d', file], {
+        const trigInput = resolveExampleTrigInput(examplesDir, file);
+        const args = [eyelingJsPath, '-d'];
+        if (trigInput) args.push('-r');
+        args.push(file);
+        if (trigInput) args.push(trigInput.rel);
+
+        const r = cp.spawnSync(process.execPath, args, {
           cwd: examplesDir,
           stdio: ['ignore', 'pipe', 'pipe'],
           maxBuffer: 200 * 1024 * 1024,

package/examples/arcling/README.md

@@ -1,11 +0,0 @@
-# ARC-style examples in Eyeling
-
-This content is now integrated into the handbook:
-
-- [Appendix F — The ARC approach: Answer • Reason Why • Check](../../HANDBOOK.md#app-f)
-
-That appendix now includes:
-
-- a brief explanation of ARC,
-- a brief explanation of the Insight Economy,
-- and links to the ARC-style examples in `examples/` together with their outputs in `examples/output/`.

package/examples/input/annotation.ttl

@@ -1,6 +0,0 @@
-VERSION "1.2"
-
-PREFIX : <http://example.com/>
-PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
-
-:a :name "Alice" ~ :t {| :statedBy :bob ; :recorded "2021-07-07"^^xsd:date |} .

package/examples/input/collection.ttl

@@ -1,13 +0,0 @@
-PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
-PREFIX : <http://example.org/stuff/1.0/>
-
-_:b0  :p2  :q2 .
-_:b0  rdf:first  1 ;
-      rdf:rest   _:b1 .
-_:b1  rdf:first  _:b2 .
-_:b2  :p         :q .
-_:b1  rdf:rest   _:b3 .
-_:b3  rdf:first  _:b4 .
-_:b4  rdf:first  2 ;
-      rdf:rest   rdf:nil .
-_:b3  rdf:rest   rdf:nil .

package/examples/input/reifies.ttl

@@ -1,10 +0,0 @@
-VERSION "1.2"
-
-PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
-PREFIX :    <http://www.example.org/>
-
-_:b rdf:reifies <<(:Socrates a :Human)>> .
-_:b :is true .
-
-:employee38 :familyName "Smith" .
-<<:employee38 :jobTitle "Assistant Designer" ~ _:id>> :accordingTo :employee22 .

package/examples/input/triple-term.ttl

@@ -1,8 +0,0 @@
-VERSION "1.2"
-
-PREFIX :    <http://www.example.org/>
-PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
-
-_:e38  :familyName  "Smith" .
-_:anno rdf:reifies <<( _:e38  :jobTitle    "Designer" )>> .
-_:anno :accordingTo _:e22 .

package/examples/reifies.n3

@@ -1,8 +0,0 @@
-@prefix : <http://www.example.org/> .
-@prefix log: <http://www.w3.org/2000/10/swap/log#> .
-
-_:b log:nameOf { :Socrates a :Human . } .
-_:b :is true .
-:employee38 :familyName "Smith" .
-_:id log:nameOf { :employee38 :jobTitle "Assistant Designer" . } .
-_:id :accordingTo :employee22 .

package/examples/triple-term.n3

@@ -1,7 +0,0 @@
-@prefix : <http://www.example.org/> .
-@prefix skolem: <https://eyereasoner.github.io/.well-known/genid/3ce038d5-ea5f-5c1e-8635-dcdabec19d5f#> .
-@prefix log: <http://www.w3.org/2000/10/swap/log#> .
-
-skolem:e38 :familyName "Smith" .
-_:anno log:nameOf { skolem:e38 :jobTitle "Designer" . } .
-_:anno :accordingTo _:e22 .