aontu 0.3.0 → 0.6.1

package/lib/val.ts

@@ -21,6 +21,15 @@ TOP -> Scalar/Boolean -> BooleanVal
 */
 
 
+import type {
+  Val,
+} from './type'
+
+import {
+  DONE,
+  TOP,
+} from './type'
+
 import {
   Context,
 } from './unify'
@@ -31,155 +40,18 @@ import {
 } from './lang'
 
 
-import {
-  unite
-} from './op/op'
-
-
-type ValMap = { [key: string]: Val }
-type ValList = Val[]
-
-
-const DONE = -1
-
-
-// There can be only one.
-const TOP: Val = {
-  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
-  },
-
-}
-
-
-
-abstract class Val {
-  id: number
-  done: number = 0
-  path: string[]
-  row: number = -1
-  col: number = -1
-  url: string = ''
-
-  top?: boolean
-
-  // Actual native value.
-  peg?: any
-
-  // TODO: used for top level result - not great
-  err?: any[]
-  deps?: any
-
-  constructor(peg?: any, ctx?: Context) {
-    this.peg = peg
-    this.path = (ctx && ctx.path) || []
-    this.id = (ctx && ctx.vc++) || (9e9 + Math.floor(Math.random() * (1e9)))
-  }
-
-  same(peer: Val): boolean {
-    return this === peer
-  }
-
-  get site(): Site {
-    return new Site(this)
-  }
-
-
-  // TODO: can ctx be optional?
-  abstract unify(peer: Val, ctx: Context): Val
-  abstract get canon(): string
-  abstract gen(ctx?: Context): any
-}
-
-
-
-class Nil extends Val {
-  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)
+import { Nil } from './val/Nil'
 
-    // 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
+import {
+  ValBase,
+} from './val/ValBase'
 
-      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
-  }
-}
 
 
 // A ScalarType for integers. Number includes floats.
@@ -194,7 +66,7 @@ type ScalarConstructor =
   (typeof Integer.constructor)
 
 
-class ScalarTypeVal extends Val {
+class ScalarTypeVal extends ValBase {
   constructor(peg: ScalarConstructor, ctx?: Context) {
     super(peg, ctx)
     this.done = DONE
@@ -239,7 +111,7 @@ class ScalarTypeVal extends Val {
 }
 
 
-class ScalarVal<T> extends Val {
+class ScalarVal<T> extends ValBase {
   type: any
   constructor(peg: T, type: ScalarConstructor, ctx?: Context) {
     super(peg, ctx)
@@ -335,672 +207,13 @@ class BooleanVal extends ScalarVal<boolean> {
 
 
 
-class MapVal extends Val {
-  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 {
-    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
-  }
-}
-
-
-
-class ListVal extends Val {
-  static SPREAD = Symbol('spread')
-
-  spread = {
-    cj: (undefined as Val | undefined),
-  }
-
-  constructor(peg: ValList, ctx?: Context) {
-    super(peg, ctx)
-
-    let spread = (this.peg as any)[ListVal.SPREAD]
-    delete (this.peg as any)[ListVal.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 {
-    let done: boolean = true
-    let out: ListVal = TOP === peer ? this : new ListVal([], 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.done = this.done + 1
-
-    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)
-
-      done = (done && DONE === out.peg[key].done)
-    }
-
-    if (peer instanceof ListVal) {
-      let upeer: ListVal = (unite(ctx, peer) as ListVal)
-
-      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 :
-                unite(ctx.descend(peerkey), child, peerchild)
-
-        if (this.spread.cj) {
-          out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
-        }
-
-        done = (done && DONE === oval.done)
-
-      }
-    }
-    else if (TOP !== peer) {
-      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
-        // NOTE: handle array non-index key vals
-        // .map(k => [JSON.stringify(k) + ':' + this.peg[k].canon]).join(',') +
-        .map(k => [this.peg[k].canon]).join(',') +
-      ']'
-  }
-
-  gen(ctx?: Context) {
-    let out: any = this.peg.map((v: Val) => v.gen(ctx))
-    // for (let p in this.peg) {
-    //   out[p] = this.peg[p].gen(ctx)
-    // }
-
-    return out
-  }
-}
-
-
-
-
-// TODO: move main logic to op/conjunct
-class ConjunctVal extends Val {
-  constructor(peg: Val[], ctx?: Context) {
-    super(peg, ctx)
-  }
-
-  // NOTE: mutation!
-  append(peer: Val): ConjunctVal {
-    this.peg.push(peer)
-    return this
-  }
-
-  unify(peer: Val, ctx: Context): Val {
-    let done = true
-
-    // Unify each term of conjunct against peer
-    let upeer: Val[] = []
-
-    for (let vI = 0; vI < this.peg.length; vI++) {
-      // upeer[vI] = this.peg[vI].unify(peer, ctx)
-      upeer[vI] = unite(ctx, this.peg[vI], peer)
-      done = done && DONE === upeer[vI].done
-      // // console.log('Ca', vI, this.peg[vI].canon, peer.canon, upeer[vI].canon)
-
-      if (upeer[vI] instanceof Nil) {
-        return Nil.make(
-          ctx,
-          '&peer[' + upeer[vI].canon + ',' + peer.canon + ']',
-          this.peg[vI],
-          peer
-        )
-      }
-    }
-
-    // // console.log('Cb', upeer.map(x => x.canon))
-
-
-    // TODO: FIX: conjuncts get replicated inside each other
-    // 1&/x => CV[CV[1&/x]]
-
-    // Unify each term of conjunct against following sibling,
-    // reducing to smallest conjunct or single val
-    let outvals: Val[] = 0 < upeer.length ? [upeer[0]] : []
-
-    let oI = 0
-    for (let uI = 1; uI < upeer.length; uI++) {
-      // // console.log('Cu', oI, uI, outvals.map(x => x.canon))
-
-      if (outvals[oI] instanceof ConjunctVal) {
-        outvals.splice(oI, 0, ...outvals[oI].peg)
-        oI += outvals[oI].peg.length
-        done = false
-      }
-      else {
-        outvals[oI] = null == outvals[oI] ? upeer[uI] :
-          //outvals[oI].unify(upeer[uI], ctx)
-          unite(ctx, outvals[oI], upeer[uI])
-        done = done && DONE === outvals[oI].done
-
-        // Conjuct fails
-        if (outvals[oI] instanceof Nil) {
-          return outvals[oI]
-
-          /*
-          return Nil.make(
-            ctx,
-            '&reduce[' + outvals[oI].canon + ',' + upeer[uI].canon + ']',
-            outvals[oI],
-            upeer[uI]
-          )
-          */
-        }
-      }
-    }
-
-    // // console.log('Cc', outvals.map(x => x.canon), outvals)
-
-    let out: Val
-
-    //let why = ''
-
-    if (0 === outvals.length) {
-      //out = Nil.make(ctx, '&empty', this)
-
-      // Empty conjuncts evaporate.
-      out = TOP
-      //why += 'A'
-    }
-
-    // TODO: corrects CV[CV[1&/x]] issue above, but swaps term order!
-    else if (1 === outvals.length) {
-      out = outvals[0]
-      //why += 'B'
-    }
-    else {
-      out = new ConjunctVal(outvals, ctx)
-      //why += 'C'
-    }
-
-    // // console.log('Cd', why, out.peg)
-
-    out.done = done ? DONE : this.done + 1
-
-    return out
-  }
-
-  // TODO: need a well-defined val order so conjunt canon is always the same
-  get canon() {
-    return this.peg.map((v: Val) => v.canon).join('&')
-  }
-
-  gen(ctx?: Context) {
-    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
-  }
-}
-
-
-
-// TODO: move main logic to op/disjunct
-class DisjunctVal extends Val {
-  // TODO: sites from normalization of orginal Disjuncts, as well as child pegs
-  constructor(peg: Val[], ctx?: Context, _sites?: Site[]) {
-    super(peg, ctx)
-  }
-
-  // NOTE: mutation!
-  append(peer: Val): DisjunctVal {
-    this.peg.push(peer)
-    return this
-  }
-
-  unify(peer: Val, ctx: Context): Val {
-    let done = true
-
-    let oval: Val[] = []
-
-    //console.log('oval', this.canon, peer.canon)
-
-    // Conjunction (&) distributes over disjunction (|)
-    for (let vI = 0; vI < this.peg.length; vI++) {
-      //oval[vI] = this.peg[vI].unify(peer, ctx)
-      oval[vI] = unite(ctx, this.peg[vI], peer)
-      //console.log('ovalA', vI, this.peg[vI].canon, peer.canon, oval[vI].canon)
-
-      done = done && DONE === oval[vI].done
-    }
-
-    //console.log('ovalB', oval.map(v => v.canon))
-
-    // Remove duplicates, and normalize
-    if (1 < oval.length) {
-      for (let vI = 0; vI < oval.length; vI++) {
-        if (oval[vI] instanceof DisjunctVal) {
-          oval.splice(vI, 1, ...oval[vI].peg)
-        }
-      }
-
-      //console.log('ovalC', oval.map(v => v.canon))
-
-      // TODO: not an error Nil!
-      let remove = new Nil()
-      for (let vI = 0; vI < oval.length; vI++) {
-        for (let kI = vI + 1; kI < oval.length; kI++) {
-          if (oval[kI].same(oval[vI])) {
-            oval[kI] = remove
-          }
-        }
-      }
-
-      //console.log('ovalD', oval.map(v => v.canon))
-
-      oval = oval.filter(v => !(v instanceof Nil))
-    }
-
-    let out: Val
-
-    if (1 == oval.length) {
-      out = oval[0]
-    }
-    else if (0 == oval.length) {
-      return Nil.make(ctx, '|:empty', this)
-    }
-    else {
-      out = new DisjunctVal(oval, ctx)
-    }
-
-    out.done = done ? DONE : this.done + 1
-
-    return out
-  }
-  get canon() {
-    return this.peg.map((v: Val) => v.canon).join('|')
-  }
-  gen(ctx?: Context) {
-    if (0 < this.peg.length) {
-
-      let vals = this.peg.filter((v: Val) => v instanceof PrefVal)
-
-      vals = 0 === vals.length ? this.peg : vals
-
-      let val = vals[0]
-
-      for (let vI = 1; vI < this.peg.length; vI++) {
-        val = val.unify(this.peg[vI])
-      }
-
-      return val.gen(ctx)
-    }
-
-    return undefined
-  }
-}
-
-
-
-class RefVal extends Val {
-  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
-  }
-
-
-  get canon() {
-    return this.peg
-  }
-
-
-  gen(_ctx?: Context) {
-    return undefined
-  }
-}
-
-
-class PrefVal extends Val {
-  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
-  }
-
-  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 {
-  DONE,
   Integer,
-  Val,
-  TOP,
-  Nil,
   ScalarTypeVal,
   NumberVal,
   StringVal,
   BooleanVal,
   IntegerVal,
-  MapVal,
-  ListVal,
-  ConjunctVal,
-  DisjunctVal,
-  RefVal,
-  PrefVal,
 }