aontu 0.4.0 → 0.4.2

package/dist/lib/common.d.ts

@@ -1,5 +1,5 @@
 import { Resolver } from '@jsonic/multisource';
-declare type Options = {
+type Options = {
     src: string;
     print: number;
     resolver?: Resolver;

package/dist/lib/op/op.d.ts

@@ -2,5 +2,5 @@ import { Context } from '../unify';
 import { Val } from '../val';
 import { disjunct } from './disjunct';
 import { unite } from './unite';
-declare type Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => Val;
+type Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => Val;
 export { Operation, disjunct, unite, };

package/dist/lib/unify.d.ts

@@ -1,6 +1,6 @@
 import { Val, RefVal, MapVal, Nil } from './val';
 import { Lang } from './lang';
-declare type Path = string[];
+type Path = string[];
 declare class Context {
     root: Val;
     path: Path;

package/dist/lib/val.d.ts

@@ -1,9 +1,9 @@
 import { Context } from './unify';
 import { Site } from './lang';
-declare type ValMap = {
+type ValMap = {
     [key: string]: Val;
 };
-declare type ValList = Val[];
+type ValList = Val[];
 declare const DONE = -1;
 declare const TOP: Val;
 declare abstract class Val {
@@ -37,7 +37,7 @@ declare class Nil extends Val {
 }
 declare class Integer {
 }
-declare type ScalarConstructor = StringConstructor | NumberConstructor | BooleanConstructor | (typeof Integer.constructor);
+type ScalarConstructor = StringConstructor | NumberConstructor | BooleanConstructor | (typeof Integer.constructor);
 declare class ScalarTypeVal extends Val {
     constructor(peg: ScalarConstructor, ctx?: Context);
     unify(peer: Val, ctx: Context): Val;

package/lib/val/RefVal.ts~

@@ -0,0 +1,319 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License */
+
+// TODO: infinite recursion protection
+
+
+// NOTES
+// - Vals are immutable
+// - each Val must handle all parent and child unifications explicitly
+// - performance is not considered yet
+
+
+
+/*
+
+TOP -> Scalar/Boolean -> BooleanVal
+    -> Scalar/String  -> StringVal
+    -> Scalar/Number  -> NumberVal -> IntegerVal
+         -> Scalar/Integer 
+    -> Scalar/Integer -> IntegerVal
+
+*/
+
+
+import type {
+  Val,
+  ValMap,
+  ValList,
+} from './type'
+
+import {
+  DONE,
+  TOP,
+} from './type'
+
+import {
+  Context,
+} from './unify'
+
+
+import {
+  Site
+} from './lang'
+
+
+import {
+  unite
+} from './op/op'
+
+import { Nil } from './val/Nil'
+
+import {
+  ValBase,
+} from './val/ValBase'
+
+import { ConjunctVal } from './val/ConjunctVal'
+
+
+
+
+
+
+// A ScalarType for integers. Number includes floats.
+class Integer { }
+
+
+
+type ScalarConstructor =
+  StringConstructor |
+  NumberConstructor |
+  BooleanConstructor |
+  (typeof Integer.constructor)
+
+
+class ScalarTypeVal extends ValBase {
+  constructor(peg: ScalarConstructor, ctx?: Context) {
+    super(peg, ctx)
+    this.done = DONE
+  }
+
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarVal) {
+      if (peer.type === this.peg) {
+        return peer
+      }
+      else if (Number === this.peg && Integer === peer.type) {
+        return peer
+      }
+      return Nil.make(ctx, 'no-scalar-unify', this, peer)
+    }
+    else {
+      if (peer instanceof ScalarTypeVal) {
+        if (Number === this.peg && Integer === peer.peg) {
+          return peer
+        }
+        else if (Number === peer.peg && Integer === this.peg) {
+          return this
+        }
+      }
+      return Nil.make(ctx, 'scalar-type', this, peer)
+    }
+  }
+
+  get canon() {
+    let ctor = (this.peg as any)
+    return ctor.name.toLowerCase()
+  }
+
+  same(peer: Val): boolean {
+    return peer instanceof ScalarTypeVal ? this.peg === peer.peg : super.same(peer)
+  }
+
+  gen(_ctx?: Context) {
+    return undefined
+  }
+
+}
+
+
+class ScalarVal<T> extends ValBase {
+  type: any
+  constructor(peg: T, type: ScalarConstructor, ctx?: Context) {
+    super(peg, ctx)
+    this.type = type
+    this.done = DONE
+  }
+  unify(peer: Val, ctx: Context): Val {
+    // Exactly equal scalars are handled in op/unite
+    if (peer instanceof ScalarTypeVal) {
+      return peer.unify(this, ctx)
+    }
+    return Nil.make(ctx, 'scalar', this, peer)
+  }
+  get canon() {
+    return (this.peg as any).toString()
+  }
+  same(peer: Val): boolean {
+    return peer instanceof ScalarVal ? peer.peg === this.peg : super.same(peer)
+  }
+
+  gen(_ctx?: Context) {
+    return this.peg
+  }
+}
+
+
+class NumberVal extends ScalarVal<number> {
+  constructor(peg: number, ctx?: Context) {
+    super(peg, Number, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarVal && peer.type === Integer) {
+      return peer
+    }
+    else {
+      return super.unify(peer, ctx)
+    }
+  }
+}
+
+
+class IntegerVal extends ScalarVal<number> {
+  constructor(peg: number, ctx?: Context) {
+    if (!Number.isInteger(peg)) {
+      // TODO: use Nil?
+      throw new Error('not-integer')
+    }
+    super(peg, Integer, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarTypeVal && peer.peg === Number) {
+      return this
+    }
+    else if (peer instanceof ScalarVal &&
+      peer.type === Number &&
+      this.peg === peer.peg) {
+      return this
+    }
+    else {
+      return super.unify(peer, ctx)
+    }
+  }
+}
+
+
+class StringVal extends ScalarVal<string> {
+  constructor(peg: string, ctx?: Context) {
+    super(peg, String, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    return super.unify(peer, ctx)
+  }
+  get canon() {
+    return JSON.stringify(this.peg)
+  }
+
+}
+
+
+class BooleanVal extends ScalarVal<boolean> {
+  constructor(peg: boolean, ctx?: Context) {
+    super(peg, Boolean, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    return super.unify(peer, ctx)
+  }
+
+  static TRUE = new BooleanVal(true, new Context({ vc: 1, root: TOP }))
+  static FALSE = new BooleanVal(false, new Context({ vc: 2, root: TOP }))
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class RefVal extends ValBase {
+  parts: string[]
+  absolute: boolean
+  sep = '.'
+
+  constructor(peg: any[], abs?: boolean) {
+    super('')
+    this.absolute = true === abs
+    this.parts = []
+
+    for (let part of peg) {
+      this.append(part)
+    }
+  }
+
+
+  append(part: any) {
+    //console.log('APPEND 0', part)
+
+    if ('string' === typeof part) {
+      this.parts.push(part)
+    }
+
+    else if (part instanceof StringVal) {
+      this.parts.push(part.peg)
+    }
+
+    else if (part instanceof RefVal) {
+      this.parts.push(...part.parts)
+
+      if (part.absolute) {
+        this.absolute = true
+      }
+    }
+
+    this.peg = (this.absolute ? this.sep : '') + this.parts.join(this.sep)
+  }
+
+  unify(peer: Val, ctx: Context): Val {
+    let resolved: Val | undefined = null == ctx ? this : ctx.find(this)
+
+    // TODO: large amount of reruns needed? why?
+    resolved = null == resolved && 999 < this.done ?
+      Nil.make(ctx, 'no-path', this, peer) : (resolved || this)
+    let out: Val
+
+    if (resolved instanceof RefVal) {
+      if (TOP === peer) {
+        out = this
+      }
+      else if (peer instanceof Nil) {
+        out = Nil.make(ctx, 'ref[' + this.peg + ']', this, peer)
+      }
+      else {
+        // Ensure RefVal done is incremented
+        this.done = DONE === this.done ? DONE : this.done + 1
+        out = new ConjunctVal([this, peer], ctx)
+      }
+    }
+    else {
+      out = unite(ctx, resolved, peer)
+    }
+
+    out.done = DONE === out.done ? DONE : this.done + 1
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : this.peg === peer.peg
+  }
+
+
+  get canon() {
+    return this.peg
+  }
+
+
+  gen(_ctx?: Context) {
+    return undefined
+  }
+}
+
+
+export {
+  Integer,
+  TOP,
+  ScalarTypeVal,
+  NumberVal,
+  StringVal,
+  BooleanVal,
+  IntegerVal,
+  RefVal,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aontu",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "main": "dist/aontu.js",
   "type": "commonjs",
   "browser": "dist/aontu.min.js",
@@ -39,11 +39,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@jsonic/directive": "^0.8.0",
-    "@jsonic/expr": "^0.5.0",
-    "@jsonic/jsonic-next": "^2.3.0",
-    "@jsonic/multisource": "^0.7.0",
-    "@jsonic/path": "^0.2.0",
+    "@jsonic/directive": "0.8.0",
+    "@jsonic/expr": "0.5.0",
+    "@jsonic/jsonic-next": "2.3.0",
+    "@jsonic/multisource": "0.7.0",
+    "@jsonic/path": "0.2.0",
     "@types/node": "^18.0.3"
   },
   "devDependencies": {