aontu 0.3.0 → 0.6.1

package/lib/val/MapVal.ts

@@ -0,0 +1,226 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValMap,
+} from '../type'
+
+import {
+  DONE,
+  TOP,
+} from '../type'
+
+import {
+  Context,
+} from '../unify'
+
+
+import {
+  Site
+} from '../lang'
+
+
+import {
+  unite
+} from '../op/op'
+
+import {
+  ValBase,
+} from '../val/ValBase'
+
+import {
+  Nil,
+} from './Nil'
+
+import {
+  ConjunctVal,
+} from './ConjunctVal'
+
+
+
+
+
+
+class MapVal extends ValBase {
+  static SPREAD = Symbol('spread')
+
+  spread = {
+    cj: (undefined as Val | undefined),
+  }
+
+  constructor(peg: ValMap, ctx?: Context) {
+    super(peg, ctx)
+
+    let spread = (this.peg as any)[MapVal.SPREAD]
+    delete (this.peg as any)[MapVal.SPREAD]
+
+    if (spread) {
+      if ('&' === spread.o) {
+        // TODO: handle existing spread!
+        this.spread.cj =
+          new ConjunctVal(Array.isArray(spread.v) ? spread.v : [spread.v], 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 {
+    // console.log('QQQ ctx', !!ctx)
+    if (null == ctx) {
+      console.trace()
+    }
+
+    let done: boolean = true
+    let out: MapVal = TOP === peer ? this : new MapVal({}, 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.done = this.done + 1
+
+    if (this.spread.cj) {
+      //out.spread.cj =
+      //  DONE !== this.spread.cj.done ? this.spread.cj.unify(TOP, ctx) :
+      //    this.spread.cj
+      out.spread.cj =
+        DONE !== this.spread.cj.done ? unite(ctx, this.spread.cj) :
+          this.spread.cj
+
+    }
+
+
+    // console.log(
+    //   ('  '.repeat(ctx.path.length)),
+    //   'MV spread', this.id, peer.id, out.id, '|',
+    //   this.canon, peer.canon, out.canon, '|',
+    //   (this.spread.cj || {}).done,
+    //   (this.spread.cj || {}).canon, (out.spread.cj || {}).canon)
+
+    let spread_cj = out.spread.cj || TOP
+
+    // Always unify children first
+    for (let key in this.peg) {
+      //let oval = out.peg[key] = this.peg[key].unify(spread_cj, ctx.descend(key))
+      //let oval =
+
+      out.peg[key] =
+        unite(ctx.descend(key), this.peg[key], spread_cj)
+
+      done = (done && DONE === out.peg[key].done)
+
+      //if (oval instanceof Nil) {
+      // ctx.err.push(oval)
+      //}
+    }
+
+    // console.log(
+    //   ('  '.repeat(ctx.path.length)),
+    //   'MV child ', this.id, peer.id, out.id, '|',
+    //   this.canon, peer.canon, out.canon, '|',
+    //   this.constructor.name,
+    //   peer.constructor.name,
+    //   out.constructor.name,
+    // )
+
+    if (peer instanceof MapVal) {
+      //let upeer: MapVal = (peer.unify(TOP, ctx) as MapVal)
+      let upeer: MapVal = (unite(ctx, peer) as MapVal)
+
+      // console.log(
+      //   ('  '.repeat(ctx.path.length)),
+      //   'MV peer A', this.id, peer.id, out.id, '|',
+      //   Object.keys(this.peg), Object.keys(upeer.peg), Object.keys(out.peg))
+
+      for (let peerkey in upeer.peg) {
+        let peerchild = upeer.peg[peerkey]
+        let child = out.peg[peerkey]
+
+        let oval = out.peg[peerkey] =
+          undefined === child ? peerchild :
+            child instanceof Nil ? child :
+              peerchild instanceof Nil ? peerchild :
+                //child.unify(peerchild, ctx.descend(peerkey))
+                unite(ctx.descend(peerkey), child, peerchild)
+
+        if (this.spread.cj) {
+          //out.peg[peerkey] = out.peg[peerkey].unify(spread_cj, ctx)
+          out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
+        }
+
+        done = (done && DONE === oval.done)
+
+        if (oval instanceof Nil) {
+          // ctx.err.push(oval)
+        }
+
+      }
+
+      // console.log(
+      //   ('  '.repeat(ctx.path.length)),
+      //   'MV peer B', this.id, peer.id, out.id, '|',
+      //   Object.keys(this.peg), Object.keys(upeer.peg), Object.keys(out.peg))
+
+      //out.done = done ? DONE : out.done
+
+      // console.log(' '.repeat(W) + 'MV OUT A', this.id, out.done, out.id, out.canon)//this.spread.cj, out.spread.cj)
+
+      // console.log(
+      //   ('  '.repeat(ctx.path.length)),
+      //   'MV out ', this.id, peer.id, out.id, '|',
+      //   this.canon, peer.canon, out.canon, '|',
+      //   this.constructor.name,
+      //   peer.constructor.name,
+      //   out.constructor.name,
+      // )
+
+
+    }
+    else if (TOP !== peer) {
+      //out.done = done ? DONE : out.done
+
+      //return (UNIFIER(out, peer, ctx) as MapVal)
+
+      return Nil.make(ctx, 'map', this, peer)
+    }
+
+    out.done = done ? DONE : out.done
+    return out
+  }
+
+  get canon() {
+    let keys = Object.keys(this.peg)
+    return '{' +
+      (this.spread.cj ? '&:' + this.spread.cj.canon +
+        (0 < keys.length ? ',' : '') : '') +
+      keys
+        .map(k => [JSON.stringify(k) + ':' + this.peg[k].canon]).join(',') +
+      '}'
+  }
+
+  gen(ctx: Context) {
+    let out: any = {}
+    for (let p in this.peg) {
+      out[p] = this.peg[p].gen(ctx)
+    }
+    return out
+  }
+}
+
+
+
+
+
+export {
+  MapVal
+}

package/lib/val/Nil.ts

@@ -0,0 +1,94 @@
+/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  Context,
+} from '../unify'
+
+
+import {
+  ValBase,
+} from '../val/ValBase'
+
+
+
+
+
+class Nil extends ValBase {
+  nil = true
+  why: any
+  primary?: Val
+  secondary?: Val
+
+  // TODO: include Val generating nil, thus capture type
+  static make = (ctx?: Context, why?: any, av?: Val, bv?: Val) => {
+    let nil = new Nil(why, ctx)
+
+    // TODO: this should be done lazily, for multiple terms
+
+    // Terms later in same file are considered the primary error location.
+    if (null != av) {
+      nil.row = av.row
+      nil.col = av.col
+      nil.url = av.url
+
+      nil.primary = av
+
+      if (null != bv) {
+        nil.secondary = bv
+
+        let bv_loc_wins =
+          (nil.url === bv.url) && (
+            (nil.row < bv.row) ||
+            (nil.row === bv.row && nil.col < bv.col)
+          )
+
+        if (bv_loc_wins) {
+          nil.row = bv.row
+          nil.col = bv.col
+          nil.url = bv.url
+          nil.primary = bv
+          nil.secondary = av
+        }
+      }
+    }
+
+    if (ctx) {
+      ctx.err.push(nil)
+    }
+
+    return nil
+  }
+
+  constructor(why?: any, ctx?: Context) {
+    super(null, ctx)
+    this.why = why
+
+    // Nil is always DONE, by definition.
+    this.done = DONE
+  }
+
+  unify(_peer: Val, _ctx: Context) {
+    return this
+  }
+
+  get canon() {
+    return 'nil'
+  }
+
+  gen(_ctx?: Context) {
+    return undefined
+  }
+}
+
+export {
+  Nil,
+}

package/lib/val/PrefVal.ts

@@ -0,0 +1,113 @@
+/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+} from '../type'
+
+import {
+  DONE,
+} 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'
+
+
+
+class PrefVal extends ValBase {
+  pref: Val
+  constructor(peg: any, pref?: any, ctx?: Context) {
+    super(peg, ctx)
+    this.pref = pref || peg
+  }
+
+  // PrefVal unify always returns a PrefVal
+  // PrefVals can only be removed by becoming Nil in a Disjunct
+  unify(peer: Val, ctx: Context): Val {
+    let done = true
+    let out: Val
+
+    if (peer instanceof PrefVal) {
+      out = new PrefVal(
+        unite(ctx, this.peg, peer.peg, 'Pref000'),
+        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'),
+        ctx
+      )
+    }
+
+    done = done && DONE === out.peg.done &&
+      (null != (out as PrefVal).pref ? DONE === (out as PrefVal).pref.done : true)
+
+    if (out.peg instanceof Nil) {
+      out = (out as PrefVal).pref
+    }
+    else if ((out as PrefVal).pref instanceof Nil) {
+      out = out.peg
+    }
+
+    out.done = done ? DONE : this.done + 1
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    if (null == peer) {
+      return false
+    }
+
+    let pegsame = (this.peg === peer.peg) ||
+      (this.peg instanceof ValBase && this.peg.same(peer.peg))
+
+    let prefsame = peer instanceof PrefVal &&
+      ((this.pref === peer.pref) ||
+        (this.pref instanceof ValBase && this.pref.same(peer.pref)))
+
+    return pegsame && prefsame
+  }
+
+
+  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
+
+    return undefined === val ? undefined : val.gen(ctx)
+  }
+}
+
+
+
+export {
+  PrefVal,
+}

package/lib/val/RefVal.ts

@@ -0,0 +1,126 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License */
+
+
+
+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'
+
+import { StringVal } from '../val'
+
+
+
+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 {
+  RefVal,
+}