aontu 0.0.7 → 0.1.1

package/lib/op/op.ts

@@ -0,0 +1,17 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License. */
+
+
+import { Context } from '../unify'
+import { Val } from '../val'
+
+import { disjunct } from './disjunct'
+import { unite } from './unite'
+
+
+type Operation = (ctx: Context, a?: Val, b?: Val) => Val
+
+export {
+  Operation,
+  disjunct,
+  unite,
+}

package/lib/op/unite.ts

@@ -0,0 +1,82 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License */
+
+
+// import { Site } from '../lang'
+import { Context } from '../unify'
+import {
+  Val,
+  MapVal,
+  ConjunctVal,
+  DisjunctVal,
+  RefVal,
+  PrefVal,
+  TOP,
+  Nil,
+  DONE
+} from '../val'
+import { Operation } from './op'
+
+
+// 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) => {
+  let out = a
+
+  //console.log('Ua', a && a.canon, b && b.canon)
+
+  if (b && (TOP === a || !a)) {
+    //console.log('Utb', b.canon)
+    out = b
+  }
+
+  else if (a && (TOP === b || !b)) {
+    //console.log('Uta', a.canon)
+    out = a
+  }
+
+  else if (a && b && TOP !== b) {
+    if (a instanceof Nil) {
+      out = update(a, b)
+    }
+    else if (b instanceof Nil) {
+      out = update(b, a)
+    }
+    else if (
+      b instanceof ConjunctVal ||
+      b instanceof DisjunctVal ||
+      b instanceof RefVal ||
+      b instanceof PrefVal
+    ) {
+
+      //console.log('U', a.canon, b.canon)
+      return b.unify(a, ctx)
+    }
+    else if (a.constructor === b.constructor && a.peg === b.peg) {
+      out = update(a, b)
+    }
+    else {
+      out = a.unify(b, ctx)
+    }
+  }
+
+  if (!out) {
+    out = Nil.make(ctx, 'unite', a, b)
+  }
+
+  if (DONE !== out.done) {
+    out = out.unify(TOP, ctx)
+  }
+
+  return out
+}
+
+
+function update(x: Val, _y: Val) {
+  // TODO: update x with y.site
+  return x
+}
+
+
+export {
+  unite
+}

package/lib/unify.ts

@@ -8,28 +8,72 @@ import {
   Val,
   RefVal,
   MapVal,
+  Nil,
 } from './val'
 
 import {
   Lang
 } from './lang'
 
+import {
+  unite
+} from './op/op'
+
+
+type Path = string[]
+
+
 
 class Context {
-  root: MapVal
-  constructor(cfg: any) {
+  root: Val   // Starting Val, root of paths.
+  path: Path  // Path to current Val.
+  err: Nil[]  // Nil error log of current unify.
+  vc: number  // Val counter to create unique val ids.
+
+
+  constructor(cfg: {
+    root: Val
+    err?: Nil[],
+    vc?: number
+  }) {
     this.root = cfg.root
+    this.path = []
+    this.err = cfg.err || []
+
+    // Multiple unify passes will keep incrementing Val counter.
+    this.vc = null == cfg.vc ? 1_000_000_000 : cfg.vc
+  }
+
+
+  clone(cfg: {
+    root: Val,
+    path?: Path
+  }): Context {
+    return new Context({
+      root: cfg.root,
+      err: this.err,
+      vc: this.vc,
+    })
   }
 
+
+  descend(key: string): Context {
+    return this.clone({
+      root: this.root,
+      path: this.path.concat(key),
+    })
+  }
+
+
   find(ref: RefVal) {
 
     // TODO: relative paths
-    if (ref.absolute) {
+    if (this.root instanceof MapVal && ref.absolute) {
       let node: MapVal = this.root
       let pI = 0
       for (; pI < ref.parts.length && node instanceof MapVal; pI++) {
         let part = ref.parts[pI]
-        node = node.val[part]
+        node = node.peg[part]
       }
 
       if (pI === ref.parts.length) {
@@ -43,7 +87,8 @@ class Context {
 class Unify {
   root: Val
   res: Val
-  dc = 0
+  err: Nil[]
+  dc: number
   lang: Lang
 
   constructor(root: Val | string, lang?: Lang) {
@@ -54,15 +99,29 @@ class Unify {
 
     this.root = root
     this.res = root
+    this.err = []
 
     let res = root
-    let ctx: Context
-    while (this.dc < 111 && DONE !== res.done) {
-      ctx = new Context({ root: res })
-      res = res.unify(TOP, ctx)
-      this.dc++
+    let ctx: Context = new Context({
+      root: res,
+      err: this.err,
+    })
+
+
+    // TODO: derive maxdc from res deterministically
+    // perhaps parse should count intial vals, paths, etc?
+
+
+
+
+    let maxdc = 999
+    for (this.dc = 0; this.dc < maxdc && DONE !== res.done; this.dc++) {
+      //res = res.unify(TOP, ctx)
+      res = unite(ctx, res, TOP)
+      ctx = ctx.clone({ root: res })
     }
 
+
     this.res = res
   }
 }
@@ -70,5 +129,6 @@ class Unify {
 
 export {
   Context,
+  Path,
   Unify,
 }