aontu 0.12.0 → 0.13.1

package/lib/val/MapVal.ts

@@ -1,15 +1,15 @@
-/* Copyright (c) 2021 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 
 
 import type {
   Val,
   ValMap,
+  ValSpec,
 } from '../type'
 
 import {
   DONE,
-  TOP,
 } from '../type'
 
 import {
@@ -17,30 +17,21 @@ import {
 } from '../unify'
 
 
-import {
-  Site
-} from '../lang'
-
 
 import {
   unite
 } from '../op/op'
 
-import {
-  ValBase,
-} from '../val/ValBase'
-
-import {
-  Nil,
-} from './Nil'
-
-import {
-  ConjunctVal,
-} from './ConjunctVal'
-
-
 
 
+import { TOP } from '../val'
+import { ConjunctVal } from '../val/ConjunctVal'
+import { DisjunctVal } from '../val/DisjunctVal'
+import { ListVal } from '../val/ListVal'
+import { Nil } from '../val/Nil'
+import { PrefVal } from '../val/PrefVal'
+import { RefVal } from '../val/RefVal'
+import { ValBase } from '../val/ValBase'
 
 
 class MapVal extends ValBase {
@@ -50,37 +41,48 @@ class MapVal extends ValBase {
     cj: (undefined as Val | undefined),
   }
 
-  constructor(peg: ValMap, ctx?: Context) {
-    super(peg, ctx)
+  constructor(
+    spec: {
+      peg: ValMap
+    },
+    ctx?: Context
+  ) {
+    super(spec, ctx)
+
+    if (null == this.peg) {
+      throw new Error('MapVal spec.peg undefined')
+    }
+
 
     let spread = (this.peg as any)[MapVal.SPREAD]
     delete (this.peg as any)[MapVal.SPREAD]
 
+    // console.log('MC', this.id, peg, spread)
+
     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 {
-    // if (null == ctx) {
-    //   console.trace()
-    // }
+    // let mark = Math.random()
 
     let done: boolean = true
-    let out: MapVal = TOP === peer ? this : new MapVal({}, ctx)
+    let out: MapVal = TOP === peer ? this : new MapVal({ peg: {} }, ctx)
 
     out.spread.cj = this.spread.cj
 
     if (peer instanceof MapVal) {
       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)
         )
       )
     }
@@ -88,32 +90,37 @@ class MapVal 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
-      done = (done && DONE === out.spread.cj.done)
-    }
-
-
     let spread_cj = out.spread.cj || TOP
 
-    // Always unify children first
+    // Always unify own children first
     for (let key in this.peg) {
-      // console.log('MAP ukA', key, this.peg[key].canon)
-
-      out.peg[key] =
-        unite(ctx.descend(key), this.peg[key], spread_cj)
-
-      // console.log('MAP ukB', key, out.peg[key].canon)
-
+      let keyctx = ctx.descend(key)
+      let key_spread_cj = spread_cj.clone(null, keyctx)
+
+      // console.log('M0', this.id, mark, Object.keys(this.peg).join('~'),
+      //   'p=', this.path.join('.'),
+      //   'k=', key, peer.top || peer.constructor.name,
+      //   'pp=', this.peg[key].path.join('.'),
+      //   this.peg[key].canon,
+      //   'sp=', key_spread_cj.path.join('.'),
+      //   key_spread_cj.canon)
+
+      // if (1000000000 === this.id) {
+      //   console.dir(key_spread_cj, { depth: null })
+      // }
+
+      out.peg[key] = unite(keyctx, this.peg[key], key_spread_cj, 'map-own')
       done = (done && DONE === out.peg[key].done)
     }
 
+
     if (peer instanceof MapVal) {
-      let upeer: MapVal = (unite(ctx, peer) as MapVal)
+      let upeer: MapVal = (unite(ctx, peer, undefined, 'map-peer-map') as MapVal)
 
       for (let peerkey in upeer.peg) {
+        // console.log('M1', this.id, mark, Object.keys(this.peg).join('~'),
+        //   'pk=', peerkey)
+
         let peerchild = upeer.peg[peerkey]
         let child = out.peg[peerkey]
 
@@ -121,14 +128,19 @@ class MapVal 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, 'map-peer')
 
         if (this.spread.cj) {
-          out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
-        }
-
-        done = (done && DONE === oval.done)
+          let key_ctx = ctx.descend(peerkey)
+          let key_spread_cj = spread_cj.clone(null, key_ctx)
 
+          out.peg[peerkey] =
+            new ConjunctVal({ peg: [out.peg[peerkey], key_spread_cj] }, key_ctx)
+          done = false
+        }
+        else {
+          done = (done && DONE === oval.done)
+        }
       }
     }
     else if (TOP !== peer) {
@@ -140,6 +152,20 @@ class MapVal extends ValBase {
   }
 
 
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as MapVal)
+    out.peg = {}
+    for (let entry of Object.entries(this.peg)) {
+      out.peg[entry[0]] =
+        entry[1] instanceof ValBase ? entry[1].clone(null, ctx) : entry[1]
+    }
+    if (this.spread.cj) {
+      out.spread.cj = this.spread.cj.clone(null, ctx)
+    }
+    return out
+  }
+
+
   get canon() {
     let keys = Object.keys(this.peg)
     return '{' +
@@ -151,7 +177,7 @@ class MapVal extends ValBase {
   }
 
 
-  gen(ctx: Context) {
+  gen(ctx?: Context) {
     let out: any = {}
     for (let p in this.peg) {
       out[p] = this.peg[p].gen(ctx)

package/lib/val/Nil.ts

@@ -1,8 +1,9 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
 
 
 import type {
   Val,
+  ValSpec,
 } from '../type'
 
 import {
@@ -10,16 +11,15 @@ import {
 } from '../type'
 
 import {
-  Context,
-} from '../unify'
-
+  descErr
+} from '../err'
 
 import {
-  ValBase,
-} from '../val/ValBase'
-
+  Context,
+} from '../unify'
 
 
+import { ValBase } from '../val/ValBase'
 
 
 class Nil extends ValBase {
@@ -32,8 +32,9 @@ class Nil extends ValBase {
   // TODO: include Val generating nil, thus capture type
 
   // A Nil is an error - should not happen - unify failed
+  // refactor ,make(spec,ctx)
   static make = (ctx?: Context, why?: any, av?: Val, bv?: Val) => {
-    let nil = new Nil(why, ctx)
+    let nil = new Nil({ why }, ctx)
 
     // TODO: this should be done lazily, for multiple terms
 
@@ -71,27 +72,69 @@ class Nil extends ValBase {
     return nil
   }
 
-  constructor(why?: any, ctx?: Context) {
-    super(null, ctx)
-    this.why = why
+
+  constructor(
+    spec?: {
+      why?: string
+      msg?: string
+      err?: Nil | Nil[] | Error | Error[]
+    } | string,
+    ctx?: Context
+  ) {
+    super(spec && 'string' !== typeof spec ? spec : {}, ctx)
+
+    if (spec && 'object' === typeof spec) {
+      this.why = spec?.why
+      this.msg = 'string' === typeof spec?.msg ? spec.msg : this.msg
+      this.err = spec ? (Array.isArray(spec.err) ? [...spec.err] : [spec.err]) : []
+    }
 
     // Nil is always DONE, by definition.
     this.done = DONE
   }
 
+
   unify(_peer: Val, _ctx: Context) {
     return this
   }
 
+
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as Nil)
+    out.why = this.why
+
+    // Should these clone?
+    // out.primary = this.primary?.clone()
+    // out.secondary = this.secondary?.clone()
+    out.primary = this.primary
+    out.secondary = this.secondary
+
+    out.msg = this.msg
+    return out
+  }
+
+
   get canon() {
     return 'nil'
   }
 
-  gen(_ctx?: Context) {
+  gen(ctx?: Context) {
+    // Unresolved nil cannot be generated, so always an error.
+
+    descErr(this)
+
+    if (ctx) {
+      ctx.err.push(this)
+    }
+    else {
+      throw new Error(this.msg)
+    }
+
     return undefined
   }
 }
 
+
 export {
   Nil,
 }

package/lib/val/PrefVal.ts

@@ -1,14 +1,20 @@
-/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
 
 
 import type {
   Val,
+  ValSpec,
 } from '../type'
 
 import {
   DONE,
 } from '../type'
 
+import {
+  descErr
+} from '../err'
+
 import {
   Context,
 } from '../unify'
@@ -23,19 +29,30 @@ 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 { ListVal } from '../val/ListVal'
+import { MapVal } from '../val/MapVal'
+import { Nil } from '../val/Nil'
+import { RefVal } from '../val/RefVal'
+import { ValBase } from '../val/ValBase'
 
 
 class PrefVal extends ValBase {
   pref: Val
-  constructor(peg: any, pref?: any, ctx?: Context) {
-    super(peg, ctx)
-    this.pref = pref || peg
+
+  constructor(
+    spec: {
+      peg: any,
+      pref?: any
+    },
+    ctx?: Context
+  ) {
+    super(spec, ctx)
+    this.pref = spec.pref || spec.peg
   }
 
   // PrefVal unify always returns a PrefVal
@@ -46,17 +63,21 @@ class PrefVal extends ValBase {
 
     if (peer instanceof PrefVal) {
       out = new PrefVal(
-        unite(ctx, this.peg, peer.peg, 'Pref000'),
-        unite(ctx, this.pref, peer.pref, 'Pref010'),
+        {
+          peg: unite(ctx, this.peg, peer.peg, 'Pref000'),
+          pref: unite(ctx, this.pref, peer.pref, 'Pref010'),
+        },
         ctx
       )
-
     }
+
     else {
       out = new PrefVal(
-        // TODO: find a better way to drop Nil non-errors
-        unite(ctx?.clone({ err: [] }), this.peg, peer, 'Pref020'),
-        unite(ctx?.clone({ err: [] }), this.pref, peer, 'Pref030'),
+        {
+          // TODO: find a better way to drop Nil non-errors
+          peg: unite(ctx?.clone({ err: [] }), this.peg, peer, 'Pref020'),
+          pref: unite(ctx?.clone({ err: [] }), this.pref, peer, 'Pref030'),
+        },
         ctx
       )
     }
@@ -93,16 +114,34 @@ class PrefVal extends ValBase {
   }
 
 
+  clone(spec?: ValSpec, ctx?: Context): Val {
+    let out = (super.clone(spec, ctx) as PrefVal)
+    out.pref = this.pref.clone(null, ctx)
+    return out
+  }
+
+
   get canon() {
     return this.pref instanceof Nil ? this.peg.canon : '*' + this.pref.canon
   }
 
   gen(ctx?: Context) {
     let val = !(this.pref instanceof Nil) ? this.pref :
-      !(this.peg instanceof Nil) ? this.peg :
-        undefined
+      (!(this.peg instanceof Nil) ? this.peg :
+        this.pref)
+
+    if (val instanceof Nil) {
+      descErr(val)
+
+      if (ctx) {
+        ctx.err.push(val)
+      }
+      else {
+        throw new Error(val.msg)
+      }
+    }
 
-    return undefined === val ? undefined : val.gen(ctx)
+    return val.gen(ctx)
   }
 }