aontu 0.11.0 → 0.13.0

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,13 +159,13 @@ 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)
-      // console.log('U', this.dc, res.canon)
       ctx = ctx.clone({ root: res })
     }
 

package/lib/val/ConjunctVal.ts

@@ -1,49 +1,47 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 
 import type {
   Val,
-  ValMap,
-  ValList,
+  ValSpec,
 } from '../type'
 
 import {
   DONE,
-  TOP,
 } from '../type'
 
-import {
-  ValBase,
-} from '../val/ValBase'
-
-import {
-  Nil,
-} from '../val/Nil'
-
-import { RefVal } from '../val/RefVal'
-import { MapVal } from '../val/MapVal'
 
 import {
   Context,
 } from '../unify'
 
 
-import {
-  Site
-} from '../lang'
-
 
 import {
   unite
 } from '../op/op'
 
 
+import { TOP } from '../val'
+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 { ValBase } from '../val/ValBase'
 
 
 // TODO: move main logic to op/conjunct
 class ConjunctVal extends ValBase {
-  constructor(peg: Val[], ctx?: Context) {
-    super(peg, ctx)
+
+  constructor(
+    spec: {
+      peg: Val[]
+    },
+    ctx?: Context
+  ) {
+    super(spec, ctx)
   }
 
   // NOTE: mutation!
@@ -53,6 +51,11 @@ class ConjunctVal extends ValBase {
   }
 
   unify(peer: Val, ctx: Context): Val {
+    // console.log('CONJUNCT UNIFY', this.done, this.path.join('.'), this.canon,
+    //   'P', peer.top || peer.constructor.name,
+    //  peer.done, peer.path.join('.'), peer.canon)
+
+
     const mark = (Math.random() * 1e7) % 1e6 | 0
     // console.log('CONJUNCT unify', mark, this.done, this.canon, 'peer=', peer.canon)
 
@@ -61,10 +64,12 @@ class ConjunctVal extends ValBase {
     // Unify each term of conjunct against peer
     let upeer: Val[] = []
 
+
+    // console.log('CJa' + mark, this.peg.map((p: Val) => p.canon), 'p=', peer.canon)
     for (let vI = 0; vI < this.peg.length; vI++) {
-      upeer[vI] = unite(ctx, this.peg[vI], peer)
+      upeer[vI] = unite(ctx, this.peg[vI], peer, 'cj-own' + mark)
 
-      let prevdone = done
+      // let prevdone = done
       done = done && (DONE === upeer[vI].done)
 
       // console.log('CONJUNCT pud', mark, vI, done, prevdone, '|', upeer[vI].done, upeer[vI].canon)
@@ -87,12 +92,19 @@ class ConjunctVal extends ValBase {
     let outvals: Val[] = []
     let val: Val
 
+    // let mark = Math.random()
+
+    // console.log('CJ upeer', mark, upeer.map(v => v.canon))
+
+    let t0 = upeer[0]
+
     next_term:
     for (let pI = 0; pI < upeer.length; pI++) {
-      let t0 = upeer[pI]
+      // let t0 = upeer[pI]
+      // console.log('CJ TERM t0', pI, t0.done, t0.canon)
 
       if (DONE !== t0.done) {
-        let u0 = unite(ctx, t0, TOP)
+        let u0 = unite(ctx, t0, TOP, 'cj-peer-t0')
 
         if (
           DONE !== u0.done
@@ -107,6 +119,7 @@ class ConjunctVal extends ValBase {
 
           // console.log('CONJUNCT PUSH A', u0.id, u0.canon)
           outvals.push(u0)
+          // console.log('CJ outvals A', outvals.map(v => v.canon))
           continue next_term
         }
         else {
@@ -115,41 +128,50 @@ class ConjunctVal extends ValBase {
       }
 
       let t1 = upeer[pI + 1]
+      // console.log('CJ TERM t1', pI + 1, t1?.done, t1?.canon)
 
       if (null == t1) {
         // console.log('CONJUNCT PUSH B', t0.canon)
         outvals.push(t0)
+        // console.log('CJ outvals B', outvals.map(v => v.canon))
       }
 
       // Can't unite with a RefVal, unless also a RefVal with same path.
       else if (t0 instanceof RefVal && !(t1 instanceof RefVal)) {
         // console.log('CONJUNCT PUSH D', t0.canon)
         outvals.push(t0)
+        t0 = t1
+        // console.log('CJ outvals C', outvals.map(v => v.canon))
       }
 
       else {
-        val = unite(ctx, t0, t1)
+        val = unite(ctx, t0, t1, 'cj-peer-t0t1')
         done = done && DONE === val.done
 
+        // Unite was just a conjunt anyway, so discard.
         if (val instanceof ConjunctVal) {
-          if (t0.id === val.peg[0].id) {
-            val = t0
-          }
+          // if (t0.id === val.peg[0].id) {
+          // val = t0
+          outvals.push(t0)
+          t0 = t1
+          // console.log('CJ outvals D', outvals.map(v => v.canon))
+          //}
         }
         else if (val instanceof Nil) {
           return val
         }
-
+        else {
+          t0 = val
+        }
         // TODO: t0 should become this to avoid unnecessary repasses
         // console.log('CONJUNCT PUSH C', val.canon)
-        outvals.push(val)
+        // outvals.push(val)
 
-        pI++
+        // pI++
       }
     }
 
-
-    // console.log('CONJUNCT outvals', mark, outvals.map(v => v.canon))
+    // console.log('CJ outvals', mark, outvals.map(v => v.canon))
 
     let out: Val
 
@@ -164,37 +186,52 @@ class ConjunctVal extends ValBase {
       out = outvals[0]
     }
     else {
-      out = new ConjunctVal(outvals, ctx)
+      out = new ConjunctVal({ peg: outvals }, ctx)
     }
 
     out.done = done ? DONE : this.done + 1
 
-    // console.log('CONJUNCT out', mark, out.done, out.canon)
+    // console.log('CJ out', out.done, out.canon)
 
     return out
   }
 
+
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as ConjunctVal)
+    out.peg = this.peg.map((entry: Val) => entry.clone(null, ctx))
+    return out
+  }
+
+
   // TODO: need a well-defined val order so conjunt canon is always the same
   get canon() {
+    // return '  C( ' + this.peg.map((v: Val) => v.canon).join('&') + ' )  '
     return this.peg.map((v: Val) => v.canon).join('&')
   }
 
+
   gen(ctx?: Context) {
-    if (0 < this.peg.length) {
+    throw new Error('ConjuntVal-gen')
 
-      // Default is just the first term - does this work?
-      // TODO: maybe use a PrefVal() ?
-      let v: Val = this.peg[0]
+    // if (0 < this.peg.length) {
 
+    //   // Default is just the first term - does this work?
+    //   // TODO: maybe use a PrefVal() ?
+    //   let v: Val = this.peg[0]
 
-      let out = undefined
-      if (undefined !== v && !(v instanceof Nil)) {
-        out = v.gen(ctx)
-      }
-      return out
-    }
 
-    return undefined
+    //   let out = undefined
+    //   if (undefined !== v && !(v instanceof Nil)) {
+    //     out = v.gen(ctx)
+    //   }
+    //   return out
+    // }
+    // else {
+    //   throw new Error('ConjuntVal-gen')
+    // }
+
+    // return undefined
   }
 }
 

package/lib/val/DisjunctVal.ts

@@ -1,8 +1,10 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
 
 
 import type {
   Val,
+  ValSpec,
 } from '../type'
 
 import {
@@ -24,15 +26,16 @@ import {
 } from '../op/op'
 
 
-import {
-  ValBase,
-} from '../val/ValBase'
-
-
-import { Nil } from './Nil'
-import { PrefVal } from './PrefVal'
 
 
+import { TOP } from '../val'
+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'
 
 
 
@@ -40,8 +43,14 @@ import { PrefVal } from './PrefVal'
 // TODO: move main logic to op/disjunct
 class DisjunctVal extends ValBase {
   // TODO: sites from normalization of orginal Disjuncts, as well as child pegs
-  constructor(peg: Val[], ctx?: Context, _sites?: Site[]) {
-    super(peg, ctx)
+  constructor(
+    spec: {
+      peg: Val[]
+    },
+    ctx?: Context,
+    _sites?: Site[]
+  ) {
+    super(spec, ctx)
   }
 
   // NOTE: mutation!
@@ -102,16 +111,27 @@ class DisjunctVal extends ValBase {
       return Nil.make(ctx, '|:empty', this)
     }
     else {
-      out = new DisjunctVal(oval, ctx)
+      out = new DisjunctVal({ peg: oval }, ctx)
     }
 
     out.done = done ? DONE : this.done + 1
 
     return out
   }
+
+
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as DisjunctVal)
+    out.peg = this.peg.map((entry: Val) => entry.clone(null, ctx))
+    return out
+  }
+
+
   get canon() {
     return this.peg.map((v: Val) => v.canon).join('|')
   }
+
+
   gen(ctx?: Context) {
 
     // TODO: this is not right - unresolved Disjuncts eval to undef
@@ -126,7 +146,10 @@ class DisjunctVal extends ValBase {
       let val = vals[0]
 
       for (let vI = 1; vI < this.peg.length; vI++) {
-        val = val.unify(this.peg[vI], ctx)
+        // val = val.unify(this.peg[vI], ctx)
+        let valnext = val.unify(this.peg[vI], ctx)
+        // console.log(valnext.canon, val.canon, this.peg[vI].canon, val, this.peg[vI])
+        val = valnext
       }
 
       return val.gen(ctx)

package/lib/val/ListVal.ts

@@ -3,13 +3,12 @@
 
 import type {
   Val,
-  ValMap,
   ValList,
+  ValSpec,
 } from '../type'
 
 import {
   DONE,
-  TOP,
 } from '../type'
 
 import {
@@ -26,13 +25,17 @@ import {
   unite
 } from '../op/op'
 
-import { Nil } from '../val/Nil'
 
-import {
-  ValBase,
-} from '../val/ValBase'
 
+
+import { TOP } from '../val'
 import { ConjunctVal } from '../val/ConjunctVal'
+import { DisjunctVal } from '../val/DisjunctVal'
+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'
 
 
 
@@ -45,8 +48,17 @@ class ListVal extends ValBase {
     cj: (undefined as Val | undefined),
   }
 
-  constructor(peg: ValList, ctx?: Context) {
-    super(peg, ctx)
+  constructor(
+    spec: {
+      peg: ValList
+    },
+    ctx?: Context
+  ) {
+    super(spec, ctx)
+
+    if (null == this.peg) {
+      throw new Error('ListVal spec.peg undefined')
+    }
 
     let spread = (this.peg as any)[ListVal.SPREAD]
     delete (this.peg as any)[ListVal.SPREAD]
@@ -54,24 +66,26 @@ class ListVal extends ValBase {
     if (spread) {
       if ('&' === spread.o) {
         // TODO: handle existing spread!
-        this.spread.cj =
-          new ConjunctVal(Array.isArray(spread.v) ? spread.v : [spread.v], ctx)
+        let tmv = Array.isArray(spread.v) ? spread.v : [spread.v]
+        this.spread.cj = new ConjunctVal({ peg: tmv }, ctx)
       }
     }
   }
 
+
   // NOTE: order of keys is not preserved!
   // not possible in any case - consider {a,b} unify {b,a}
   unify(peer: Val, ctx: Context): Val {
     let done: boolean = true
-    let out: ListVal = TOP === peer ? this : new ListVal([], ctx)
+    let out: ListVal = TOP === peer ? this : new ListVal({ peg: [] }, ctx)
 
     out.spread.cj = this.spread.cj
 
     if (peer instanceof ListVal) {
       out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
         null == peer.spread.cj ? out.spread.cj : (
-          out.spread.cj = new ConjunctVal([out.spread.cj, peer.spread.cj], ctx)
+          out.spread.cj =
+          new ConjunctVal({ peg: [out.spread.cj, peer.spread.cj] }, ctx)
         )
       )
     }
@@ -79,25 +93,28 @@ class ListVal extends ValBase {
 
     out.done = this.done + 1
 
-    if (this.spread.cj) {
-      out.spread.cj =
-        DONE !== this.spread.cj.done ? unite(ctx, this.spread.cj) :
-          this.spread.cj
-    }
+    // if (this.spread.cj) {
+    //   out.spread.cj =
+    //     DONE !== this.spread.cj.done ? unite(ctx, this.spread.cj) :
+    //       this.spread.cj
+    // }
 
     let spread_cj = out.spread.cj || TOP
 
     // Always unify children first
     for (let key in this.peg) {
-      out.peg[key] =
-        unite(ctx.descend(key), this.peg[key], spread_cj)
+      let keyctx = ctx.descend(key)
+      let key_spread_cj = spread_cj.clone(null, keyctx)
 
+      out.peg[key] = unite(keyctx, this.peg[key], key_spread_cj, 'list-own')
       done = (done && DONE === out.peg[key].done)
     }
 
+
     if (peer instanceof ListVal) {
-      let upeer: ListVal = (unite(ctx, peer) as ListVal)
+      let upeer: ListVal = (unite(ctx, peer, undefined, 'list-peer-list') as ListVal)
 
+      // NOTE: peerkey is the index
       for (let peerkey in upeer.peg) {
         let peerchild = upeer.peg[peerkey]
         let child = out.peg[peerkey]
@@ -106,10 +123,17 @@ class ListVal extends ValBase {
           undefined === child ? peerchild :
             child instanceof Nil ? child :
               peerchild instanceof Nil ? peerchild :
-                unite(ctx.descend(peerkey), child, peerchild)
+                unite(ctx.descend(peerkey), child, peerchild, 'list-peer')
 
         if (this.spread.cj) {
-          out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
+          let key_ctx = ctx.descend(peerkey)
+          let key_spread_cj = spread_cj.clone(null, key_ctx)
+
+          // out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
+          out.peg[peerkey] =
+            new ConjunctVal({ peg: [out.peg[peerkey], key_spread_cj] }, key_ctx)
+          done = false
+
         }
 
         done = (done && DONE === oval.done)
@@ -124,6 +148,17 @@ class ListVal extends ValBase {
     return out
   }
 
+
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as ListVal)
+    out.peg = this.peg.map((entry: Val) => entry.clone(null, ctx))
+    if (this.spread.cj) {
+      out.spread.cj = this.spread.cj.clone(null, ctx)
+    }
+    return out
+  }
+
+
   get canon() {
     let keys = Object.keys(this.peg)
     return '[' +