aontu 0.12.0 → 0.13.0

package/lib/lang.ts

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 import {
   Jsonic,
@@ -42,20 +42,21 @@ import type {
   Options,
 } from './type'
 
-import {
-  TOP
-} from './type'
 
-import { ConjunctVal } from './val/ConjunctVal'
+
 import { DisjunctVal } from './val/DisjunctVal'
-import { MapVal } from './val/MapVal'
+import { ConjunctVal } from './val/ConjunctVal'
 import { ListVal } from './val/ListVal'
+import { MapVal } from './val/MapVal'
+import { Nil } from './val/Nil'
 import { PrefVal } from './val/PrefVal'
 import { RefVal } from './val/RefVal'
-import { Nil } from './val/Nil'
+import { VarVal } from './val/VarVal'
+import { ValBase } from './val/ValBase'
 
 
 import {
+  TOP,
   ScalarTypeVal,
   Integer,
   StringVal,
@@ -80,11 +81,10 @@ class Site {
     this.col = val.col
     this.url = val.url
   }
-
-
 }
 
 
+
 let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
 
   jsonic.use(Path)
@@ -102,19 +102,19 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         // TODO: jsonic should be able to pass context into these
         'string': {
           val: (r: Rule) =>
-            addpath(new ScalarTypeVal(String), r.keep.path)
+            addpath(new ScalarTypeVal({ peg: String }), r.keep.path)
         },
         'number': {
           val: (r: Rule) =>
-            addpath(new ScalarTypeVal(Number), r.keep.path)
+            addpath(new ScalarTypeVal({ peg: Number }), r.keep.path)
         },
         'integer': {
           val: (r: Rule) =>
-            addpath(new ScalarTypeVal(Integer), r.keep.path)
+            addpath(new ScalarTypeVal({ peg: Integer }), r.keep.path)
         },
         'boolean': {
           val: (r: Rule) =>
-            addpath(new ScalarTypeVal(Boolean), r.keep.path)
+            addpath(new ScalarTypeVal({ peg: Boolean }), r.keep.path)
         },
         'nil': {
           val: (r: Rule) =>
@@ -132,7 +132,23 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         let cval = (curr as Val)
 
         if (pval?.isVal && cval?.isVal) {
-          return addpath(new ConjunctVal([pval, cval]), prev.path)
+
+          // TODO: test multi element conjuncts work
+          if (pval instanceof ConjunctVal && cval instanceof ConjunctVal) {
+            pval.append(cval)
+            return pval
+          }
+          else if (pval instanceof ConjunctVal) {
+            pval.append(cval)
+            return pval
+          }
+          // else if (cval instanceof ConjunctVal) {
+          //   cval.append(pval)
+          //   return cval
+          // }
+          else {
+            return addpath(new ConjunctVal({ peg: [pval, cval] }), prev.path)
+          }
         }
 
         // Handle defered conjuncts, where MapVal does not yet
@@ -149,17 +165,31 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
 
   let opmap: any = {
     'conjunct-infix': (r: Rule, _op: Op, terms: any) =>
-      addpath(new ConjunctVal(terms), r.keep.path),
+      addpath(new ConjunctVal({ peg: terms }), r.keep.path),
     'disjunct-infix': (r: Rule, _op: Op, terms: any) =>
-      addpath(new DisjunctVal(terms), r.keep.path),
+      addpath(new DisjunctVal({ peg: terms }), r.keep.path),
 
-    'dot-prefix': (r: Rule, _op: Op, terms: any) =>
-      addpath(new RefVal(terms, true), r.keep.path),
-    'dot-infix': (r: Rule, _op: Op, terms: any) =>
-      addpath(new RefVal(terms), r.keep.path),
+    'dot-prefix': (r: Rule, _op: Op, terms: any) => {
+      // console.log('DP', terms)
+      return addpath(new RefVal({ peg: terms, prefix: true }), r.keep.path)
+    },
+
+    'dot-infix': (r: Rule, _op: Op, terms: any) => {
+      // console.log('DI', terms)
+      return addpath(new RefVal({ peg: terms }), r.keep.path)
+    },
 
     'star-prefix': (r: Rule, _op: Op, terms: any) =>
-      addpath(new PrefVal(terms[0]), r.keep.path),
+      addpath(new PrefVal({ peg: terms[0] }), r.keep.path),
+
+    'dollar-prefix': (r: Rule, _op: Op, terms: any) => {
+      // $.a.b absolute path
+      if (terms[0] instanceof RefVal) {
+        terms[0].absolute = true
+        return terms[0]
+      }
+      return addpath(new VarVal({ peg: terms[0] }), r.keep.path)
+    },
   }
 
 
@@ -168,29 +198,34 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
       op: {
         // disjunct > conjunct: c & b|a -> c & (b|a)
         'conjunct': {
-          infix: true, src: '&', left: 14000, right: 15000
+          infix: true, src: '&', left: 14_000_000, right: 15_000_000
         },
         'disjunct': {
-          // infix: true, src: '|', left: 14000, right: 15000
-          infix: true, src: '|', left: 16000, right: 17000
+          infix: true, src: '|', left: 16_000_000, right: 17_000_000
+        },
+
+        'dollar-prefix': {
+          src: '$',
+          prefix: true,
+          right: 31_000_000,
         },
 
         'dot-infix': {
           src: '.',
           infix: true,
-          left: 15_000_000,
-          right: 14_000_000,
+          left: 25_000_000,
+          right: 24_000_000,
         },
         'dot-prefix': {
           src: '.',
           prefix: true,
-          right: 14_000_000,
+          right: 24_000_000,
         },
 
         'star': {
           src: '*',
           prefix: true,
-          right: 14_000_000,
+          right: 24_000_000,
         },
       },
       evaluate: (r: Rule, op: Op, terms: any) => {
@@ -215,18 +250,18 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         let valtype = typeof valnode
 
         if ('string' === valtype) {
-          valnode = addpath(new StringVal(r.node), r.keep.path)
+          valnode = addpath(new StringVal({ peg: r.node }), r.keep.path)
         }
         else if ('number' === valtype) {
           if (Number.isInteger(r.node)) {
-            valnode = addpath(new IntegerVal(r.node), r.keep.path)
+            valnode = addpath(new IntegerVal({ peg: r.node }), r.keep.path)
           }
           else {
-            valnode = addpath(new NumberVal(r.node), r.keep.path)
+            valnode = addpath(new NumberVal({ peg: r.node }), r.keep.path)
           }
         }
         else if ('boolean' === valtype) {
-          valnode = addpath(new BooleanVal(r.node), r.keep.path)
+          valnode = addpath(new BooleanVal({ peg: r.node }), r.keep.path)
         }
 
         let st = r.o0
@@ -262,11 +297,15 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         if (mo.___merge) {
           let mop = { ...mo }
           delete mop.___merge
-          let mopv = new MapVal(mop)
-          r.node = addpath(new ConjunctVal([mopv, ...mo.___merge]), r.keep.path)
+
+          // TODO: needs addpath?
+          let mopv = new MapVal({ peg: mop })
+
+          r.node =
+            addpath(new ConjunctVal({ peg: [mopv, ...mo.___merge] }), r.keep.path)
         }
         else {
-          r.node = addpath(new MapVal(mo), r.keep.path)
+          r.node = addpath(new MapVal({ peg: mo }), r.keep.path)
         }
 
         // return out
@@ -283,7 +322,7 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
     //   let out = orig_bc ? orig_bc.call(this, rule, ctx) : undefined
 
     rs.bc((r: Rule) => {
-      r.node = addpath(new ListVal(r.node), r.keep.path)
+      r.node = addpath(new ListVal({ peg: r.node }), r.keep.path)
 
       // return out
       return undefined
@@ -293,10 +332,22 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
   })
 
 
-
   jsonic.rule('pair', (rs: RuleSpec) => {
     rs
-      .open([{ s: [CJ, CL], p: 'val', u: { spread: true }, g: 'spread' }])
+      .open([{
+        s: [CJ, CL], p: 'val',
+        // pair:true not set, so key ignored by normal pair close
+        u: { spread: true },
+        g: 'spread'
+      }])
+
+      // NOTE: manually adjust path - @jsonic/path ignores as not pair:true
+      .ao((r) => {
+        if (0 < r.d && r.use.spread) {
+          r.child.keep.path = [...r.keep.path, '&']
+          r.child.keep.key = '&'
+        }
+      })
 
       .bc((rule: Rule) => {
         // TRAVERSE PARENTS TO GET PATH
@@ -304,6 +355,7 @@ let AontuJsonic: Plugin = function aontu(jsonic: Jsonic) {
         if (rule.use.spread) {
           rule.node[MapVal.SPREAD] =
             (rule.node[MapVal.SPREAD] || { o: rule.o0.src, v: [] })
+
           rule.node[MapVal.SPREAD].v.push(rule.child.node)
         }
 
@@ -370,6 +422,7 @@ function makeModelResolver(options: any) {
   ) {
 
     let path = 'string' === typeof spec ? spec : spec?.peg
+    // console.log('MR', path, ctx.meta)
 
     let search: any = []
     let res = memResolver(path, popts, rule, ctx, jsonic)

package/lib/op/disjunct.ts

@@ -1,24 +1,31 @@
-/* Copyright (c) 2021 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 
 import type { Val } from '../type'
 
 import { Site } from '../lang'
 import { Context } from '../unify'
-import { DisjunctVal } from '../val/DisjunctVal'
 import { Operation } from './op'
 
 
 
+import { DisjunctVal } from '../val/DisjunctVal'
+import { ConjunctVal } from '../val/ConjunctVal'
+import { ListVal } from '../val/ListVal'
+import { MapVal } from '../val/MapVal'
+import { Nil } from '../val/Nil'
+import { PrefVal } from '../val/PrefVal'
+import { RefVal } from '../val/RefVal'
 import { ValBase } from '../val/ValBase'
 
 
+
 const disjunct: Operation = (ctx?: Context, a?: Val, b?: Val) => {
   let peers: Val[] = []
   let origsites: Site[] = []
   // origsites.push(append(peers, a))
   // origsites.push(append(peers, b))
-  let out = new DisjunctVal(peers, ctx, origsites)
+  let out = new DisjunctVal({ peg: peers }, ctx, origsites)
   return out
 }
 

package/lib/op/op.ts

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021 Richard Rodger, MIT License. */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License. */
 
 
 import { Context } from '../unify'

package/lib/op/unite.ts

@@ -1,28 +1,39 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
 
 
 import type { Val } from '../type'
 
-import { DONE, TOP } from '../type'
+import { DONE } from '../type'
 import { Context } from '../unify'
 
+
 import { ConjunctVal } from '../val/ConjunctVal'
 import { DisjunctVal } from '../val/DisjunctVal'
+import { ListVal } from '../val/ListVal'
+import { MapVal } from '../val/MapVal'
+import { Nil } from '../val/Nil'
 import { PrefVal } from '../val/PrefVal'
 import { RefVal } from '../val/RefVal'
-import { Nil } from '../val/Nil'
+import { ValBase } from '../val/ValBase'
 
 
+import {
+  TOP,
+} from '../val'
 
 
 import { Operation } from './op'
 
 
+let uc = 0
+
+
 // Vals should only have to unify downwards (in .unify) over Vals they understand.
 // and for complex Vals, TOP, which means self unify if not yet done
 const unite: Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => {
   let out = a
-
+  let why = 'u'
   // console.log('AA OP unite  IN', a?.canon, b?.canon,
   //   'W', whence,
   //   'E', 0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
@@ -31,23 +42,28 @@ const unite: Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => {
   if (b && (TOP === a || !a)) {
     //console.log('Utb', b.canon)
     out = b
+    why = 'b'
   }
 
   else if (a && (TOP === b || !b)) {
     //console.log('Uta', a.canon)
     out = a
+    why = 'a'
   }
 
   else if (a && b && TOP !== b) {
     if (a instanceof Nil) {
       out = update(a, b)
+      why = 'an'
     }
     else if (b instanceof Nil) {
       out = update(b, a)
+      why = 'bn'
     }
     else if (a instanceof ConjunctVal) {
       // console.log('Q', a.canon, b.canon)
       out = a.unify(b, ctx)
+      why = 'acj'
     }
     else if (
       b instanceof ConjunctVal ||
@@ -60,29 +76,53 @@ const unite: Operation = (ctx: Context, a?: Val, b?: Val, whence?: string) => {
       // return b.unify(a, ctx)
       out = b.unify(a, ctx)
       // console.log('UO', out.canon)
+      why = 'bv'
     }
 
     // Exactly equal scalars.
     else if (a.constructor === b.constructor && a.peg === b.peg) {
       out = update(a, b)
+      why = 'up'
     }
 
     else {
       out = a.unify(b, ctx)
+      why = 'ab'
     }
   }
 
   if (!out || !out.unify) {
     out = Nil.make(ctx, 'unite', a, b)
+    why += 'N'
   }
 
   if (DONE !== out.done) {
     out = out.unify(TOP, ctx)
+    why += 'T'
   }
 
   // console.log('AA OP unite OUT', a?.canon, b?.canon, '->', out && out.canon,
   //   0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
 
+  uc++
+
+  // TODO: KEEP THIS! print in debug mode! push to ctx.log?
+  /*
+  console.log(
+    'U',
+    ('' + ctx.cc).padStart(2),
+    ('' + uc).padStart(4),
+    (whence || '').substring(0, 16).padEnd(16),
+    why.padEnd(6),
+    ctx.path.join('.').padEnd(16),
+    (a || '').constructor.name.substring(0, 3),
+    '&',
+    (b || '').constructor.name.substring(0, 3),
+    '|',
+    '  '.repeat(ctx.path.length),
+    a?.canon, '&', b?.canon, '->', out.canon)
+  */
+
   return out
 }
 

package/lib/type.ts

@@ -1,4 +1,4 @@
-/* Copyright (c) 2022 Richard Rodger, MIT License */
+/* Copyright (c) 2022-2023 Richard Rodger, MIT License */
 
 
 // TODO: refactor these out
@@ -33,25 +33,30 @@ interface Val {
   col: number
   url: string
 
-  top?: boolean
+  top: boolean
 
   // Actual native value.
-  peg?: any
+  peg: any
 
   // TODO: used for top level result - not great
-  err?: any[]
+  err: any[]
   deps?: any
 
   same(peer: Val): boolean
 
-  get site(): Site
+  // TODO: reverse args, as spec is mostly only used internally?
+  clone(spec?: ValSpec, ctx?: Context): Val
 
+  // get site(): Site
   unify(peer: Val, ctx?: Context): Val
   get canon(): string
   gen(ctx?: Context): any
 }
 
-
+type ValSpec = {
+  peg?: any,
+  [name: string]: any,
+} | null
 type ValMap = { [key: string]: Val }
 type ValList = Val[]
 
@@ -60,41 +65,9 @@ type ValList = Val[]
 const DONE = -1
 
 
-// There can be only one.
-const TOP: Val = {
-  isVal: true,
-
-  id: 0,
-  top: true,
-  peg: undefined,
-  done: DONE,
-  path: [],
-  row: -1,
-  col: -1,
-  url: '',
-
-  unify(peer: Val, _ctx: Context): Val {
-    return peer
-  },
-
-  get canon() { return 'top' },
-
-  get site() { return new Site(this) },
-
-  same(peer: Val): boolean {
-    return TOP === peer
-  },
-
-  gen: (_ctx?: Context) => {
-    return undefined
-  },
-
-}
-
-
-
 export type {
   Val,
+  ValSpec,
   ValMap,
   ValList,
   Options,
@@ -102,7 +75,6 @@ export type {
 
 export {
   DONE,
-  TOP,
   Resolver,
 }
 

package/lib/unify.ts

@@ -1,11 +1,15 @@
-/* Copyright (c) 2021 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 
 import type { Val } from './type'
 
-import { DONE, TOP } from './type'
+import { DONE, } from './type'
 
 
+import {
+  TOP
+} from './val'
+
 import {
   Lang
 } from './lang'
@@ -16,8 +20,10 @@ import {
 
 
 
-import { MapVal } from '../lib/val/MapVal'
-import { RefVal } from '../lib/val/RefVal'
+
+
+// import { MapVal } from '../lib/val/MapVal'
+// import { RefVal } from '../lib/val/RefVal'
 import { Nil } from '../lib/val/Nil'
 
 
@@ -30,18 +36,27 @@ class Context {
   path: Path  // Path to current Val.
   err: Nil[]  // Nil error log of current unify.
   vc: number  // Val counter to create unique val ids.
+  cc: number = -1
+  var: Record<string, Val> = {}
 
   constructor(cfg: {
-    root: Val
+    root: Val,
+    path?: Path,
     err?: Nil[],
-    vc?: number
+    vc?: number,
+    cc?: number,
+    var?: Record<string, Val>
   }) {
     this.root = cfg.root
-    this.path = []
+    this.path = cfg.path || []
     this.err = cfg.err || []
 
     // Multiple unify passes will keep incrementing Val counter.
     this.vc = null == cfg.vc ? 1_000_000_000 : cfg.vc
+
+    this.cc = null == cfg.cc ? this.cc : cfg.cc
+
+    this.var = cfg.var || this.var
   }
 
 
@@ -52,8 +67,11 @@ class Context {
   }): Context {
     return new Context({
       root: cfg.root || this.root,
+      path: cfg.path,
       err: cfg.err || this.err,
       vc: this.vc,
+      cc: this.cc,
+      var: { ...this.var },
     })
   }
 
@@ -66,27 +84,49 @@ class Context {
   }
 
 
-  find(ref: RefVal) {
+  // TODO: move to RefVal
+  /*
+  xfind(ref: RefVal) {
     // TODO: relative paths
     // if (this.root instanceof MapVal && ref.absolute) {
+
+    // NOTE: path *to* the ref, not the ref itself!
+    let fullpath = ref.path
+
     if (ref.absolute) {
-      let node = this.root
-      let pI = 0
-      for (; pI < ref.parts.length; pI++) {
-        let part = ref.parts[pI]
-        if (node instanceof MapVal) {
-          node = node.peg[part]
-        }
-        else {
-          break;
-        }
-      }
+      fullpath = ref.parts.slice(1) // ignore '$' at start
+    }
+    else {
+      fullpath = fullpath.concat(ref.parts)
+    }
+
+    console.log('FP', ref.absolute, ref.parts, fullpath)
 
-      if (pI === ref.parts.length) {
-        return node
+    let node = this.root
+    let pI = 0
+    for (; pI < ref.parts.length; pI++) {
+      let part = ref.parts[pI]
+      if (node instanceof MapVal) {
+        node = node.peg[part]
+      }
+      else {
+        // console.log(
+        //   'FIND', ref.parts, pI, node.constructor.name,
+        //   node.peg.map(
+        //     (n: any) =>
+        //       n.constructor.name + ':' + n.done +
+        //       ' {' + Object.keys(n.peg) + '}'
+        //   )
+        // )
+        break;
       }
     }
-  }
+
+    if (pI === ref.parts.length) {
+      return node
+    }
+    }
+    */
 }
 
 
@@ -94,10 +134,10 @@ class Unify {
   root: Val
   res: Val
   err: Nil[]
-  dc: number
+  cc: number
   lang: Lang
 
-  constructor(root: Val | string, lang?: Lang) {
+  constructor(root: Val | string, lang?: Lang, ctx?: Context) {
     this.lang = lang || new Lang()
     if ('string' === typeof root) {
       root = this.lang.parse(root)
@@ -108,7 +148,8 @@ class Unify {
     this.err = []
 
     let res = root
-    let ctx: Context = new Context({
+
+    ctx = ctx || new Context({
       root: res,
       err: this.err,
     })
@@ -118,11 +159,12 @@ class Unify {
     // perhaps parse should count intial vals, paths, etc?
 
 
-    let maxdc = 999
-    for (this.dc = 0; this.dc < maxdc && DONE !== res.done; this.dc++) {
+    let maxdc = 9 // 99
+    for (this.cc = 0; this.cc < maxdc && DONE !== res.done; this.cc++) {
+      // console.log('\n\nRES', this.dc)
       // console.log('\n\nRES', this.dc, res.canon)
       // console.dir(res, { depth: null })
-
+      ctx.cc = this.cc
       res = unite(ctx, res, TOP)
       ctx = ctx.clone({ root: res })
     }