aontu 0.28.0 → 0.30.1

package/lib/op/unite.ts

@@ -1,143 +0,0 @@
-/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
-
-
-
-import type { Val } from '../type'
-
-import { DONE } from '../type'
-import { Context } from '../unify'
-
-
-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 { PrefVal } from '../val/PrefVal'
-import { RefVal } from '../val/RefVal'
-import { ValBase } from '../val/ValBase'
-
-
-import {
-  TOP,
-} from '../val'
-
-
-import { Operation } from './op'
-
-
-let uc = 0
-
-
-// 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?: any, b?: any, whence?: string) => {
-  let out = a
-  let why = 'u'
-  // console.log('AA OP unite  IN', a?.canon, b?.canon,
-  //   'W', whence,
-  //   'E', 0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
-
-  let unified = false
-
-  if (b && (TOP === a || !a)) {
-    //console.log('Utb', b.canon)
-    out = b
-    why = 'b'
-  }
-
-  else if (a && (TOP === b || !b)) {
-    //console.log('Uta', a.canon)
-    out = a
-    why = 'a'
-  }
-
-  else if (a && b && TOP !== b) {
-    if (a.isNil) {
-      out = update(a, b)
-      why = 'an'
-    }
-    else if (b.isNil) {
-      out = update(b, a)
-      why = 'bn'
-    }
-    else if (a.isConjunctVal) {
-      // console.log('Q', a.canon, b.canon)
-      out = a.unify(b, ctx)
-      unified = true
-      why = 'acj'
-    }
-    else if (
-      b.isConjunctVal ||
-      b.isDisjunctVal ||
-      b.isRefVal ||
-      b.isPrefVal
-    ) {
-
-      // console.log('U', a.canon, b.canon)
-      // return b.unify(a, ctx)
-      out = b.unify(a, ctx)
-      unified = true
-      // console.log('UO', out.canon)
-      why = 'bv'
-    }
-
-    // Exactly equal scalars.
-    else if (a.constructor === b.constructor && a.peg === b.peg) {
-      out = update(a, b)
-      why = 'up'
-    }
-
-    else {
-      // console.log('QQQ')
-      out = a.unify(b, ctx)
-      unified = true
-      why = 'ab'
-    }
-  }
-
-  if (!out || !out.unify) {
-    out = Nil.make(ctx, 'unite', a, b)
-    why += 'N'
-  }
-
-  if (DONE !== out.done && !unified) {
-    out = out.unify(TOP, ctx)
-    why += 'T'
-  }
-
-  // console.log('AA OP unite OUT', a?.canon, b?.canon, '->', out && out.canon,
-  //   0 < ctx?.err?.length ? ctx.err.map((e: Val) => e.canon) : '')
-
-  uc++
-
-  // TODO: KEEP THIS! print in debug mode! push to ctx.log?
-  /*
-  console.log(
-    'U',
-    ('' + ctx.cc).padStart(2),
-    ('' + uc).padStart(4),
-    (whence || '').substring(0, 16).padEnd(16),
-    why.padEnd(6),
-    ctx.path.join('.').padEnd(16),
-    (a || '').constructor.name.substring(0, 3),
-    '&',
-    (b || '').constructor.name.substring(0, 3),
-    '|',
-    '  '.repeat(ctx.path.length),
-    a?.canon, '&', b?.canon, '->', out.canon)
-  */
-
-  return out
-}
-
-
-function update(x: Val, _y: Val) {
-  // TODO: update x with y.site
-  return x
-}
-
-
-export {
-  unite
-}

package/lib/type.ts

@@ -1,83 +0,0 @@
-/* Copyright (c) 2022-2023 Richard Rodger, MIT License */
-
-
-// TODO: refactor these out
-
-import { Resolver } from '@jsonic/multisource'
-
-import { Context } from './unify'
-
-import {
-  Site
-} from './lang'
-
-
-
-type Options = {
-  src: string    // Source text.
-  print: number  // Print debug verbosity
-  resolver?: Resolver // Source resolver
-  base?: string // Base path for resolver
-  path?: string // Path of entry file
-  debug?: boolean
-  trace?: boolean
-}
-
-
-
-
-interface Val {
-  isVal: boolean
-
-  id: number
-  done: number
-  path: string[]
-  row: number
-  col: number
-  url: string
-
-  top: boolean
-
-  // Actual native value.
-  peg: any
-
-  // TODO: used for top level result - not great
-  err: any[]
-  deps?: any
-
-  same(peer: Val): boolean
-
-  // TODO: reverse args, as spec is mostly only used internally?
-  clone(spec?: ValSpec, ctx?: Context): Val
-
-  // get site(): Site
-  unify(peer: Val, ctx?: Context): Val
-  get canon(): string
-  gen(ctx?: Context): any
-}
-
-type ValSpec = {
-  peg?: any,
-  [name: string]: any,
-} | null
-type ValMap = { [key: string]: Val }
-type ValList = Val[]
-
-
-
-const DONE = -1
-
-
-export type {
-  Val,
-  ValSpec,
-  ValMap,
-  ValList,
-  Options,
-}
-
-export {
-  DONE,
-  Resolver,
-}
-

package/lib/unify.ts

@@ -1,144 +0,0 @@
-/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
-
-
-import type { Val } from './type'
-
-import { DONE, } from './type'
-
-
-import {
-  TOP
-} from './val'
-
-import {
-  Lang
-} from './lang'
-
-import {
-  unite
-} from './op/op'
-
-
-
-
-
-// import { MapVal } from '../lib/val/MapVal'
-// import { RefVal } from '../lib/val/RefVal'
-import { Nil } from '../lib/val/Nil'
-
-
-type Path = string[]
-
-
-
-class Context {
-  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.
-  cc: number = -1
-  var: Record<string, Val> = {}
-
-  constructor(cfg: {
-    root: Val,
-    path?: Path,
-    err?: Nil[],
-    vc?: number,
-    cc?: number,
-    var?: Record<string, Val>
-  }) {
-    this.root = cfg.root
-    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
-  }
-
-
-  clone(cfg: {
-    root?: Val,
-    path?: Path,
-    err?: Nil[],
-  }): 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 },
-    })
-  }
-
-
-  descend(key: string): Context {
-    return this.clone({
-      root: this.root,
-      path: this.path.concat(key),
-    })
-  }
-}
-
-
-class Unify {
-  root: Val
-  res: Val
-  err: Nil[]
-  cc: number
-  lang: Lang
-
-  constructor(root: Val | string, lang?: Lang, ctx?: Context) {
-    // console.log('ROOT-A', root)
-
-    this.lang = lang || new Lang()
-    if ('string' === typeof root) {
-      root = this.lang.parse(root)
-    }
-
-    // console.log('ROOT-B', root)
-
-    this.cc = 0
-    this.root = root
-    this.res = root
-    this.err = root.err || []
-
-    let res = root
-
-    // Only unify if no syntax errors
-    if (!(root as Nil).nil) {
-      ctx = ctx || new Context({
-        root: res,
-        err: this.err,
-      })
-
-
-      // TODO: derive maxdc from res deterministically
-      // perhaps parse should count intial vals, paths, etc?
-
-
-      let maxdc = 9 // 99
-      for (; this.cc < maxdc && DONE !== res.done; this.cc++) {
-        ctx.cc = this.cc
-        res = unite(ctx, res, TOP)
-        ctx = ctx.clone({ root: res })
-
-        // console.log('==============', this.cc)
-      }
-    }
-
-
-    this.res = res
-  }
-}
-
-
-export {
-  Context,
-  Path,
-  Unify,
-}

package/lib/utility.ts

@@ -1,23 +0,0 @@
-/* Copyright (c) 2023 Richard Rodger, MIT License */
-
-
-import type { Val } from './type'
-
-function formatPath(path: Val | string[], absolute?: boolean) {
-  let parts: string[]
-  if (Array.isArray(path)) {
-    parts = path
-  }
-  else {
-    parts = path.path
-  }
-
-  let pathstr = (0 < parts.length && false !== absolute ? '$.' : '') + parts.join('.')
-
-  return pathstr
-}
-
-export {
-  formatPath
-}
-

package/lib/val/ConjunctVal.ts

@@ -1,300 +0,0 @@
-/* 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'
-
-
-
-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 {
-  isBinaryOp = true
-  isConjunctVal = true
-
-  constructor(
-    spec: {
-      peg: Val[]
-    },
-    ctx?: Context
-  ) {
-    super(spec, ctx)
-    // console.log('NEWCJ')
-    // console.trace()
-  }
-
-  // NOTE: mutation!
-  append(peer: Val): ConjunctVal {
-    this.peg.push(peer)
-    return this
-  }
-
-  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)
-
-    let done = true
-
-    // 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, 'cj-own' + mark)
-
-      // let prevdone = done
-      done = done && (DONE === upeer[vI].done)
-
-      // console.log('CONJUNCT pud', mark, vI, done, prevdone, '|', upeer[vI].done, upeer[vI].canon)
-
-      if (upeer[vI] instanceof Nil) {
-        return Nil.make(
-          ctx,
-          '&peer[' + upeer[vI].canon + ',' + peer.canon + ']',
-          this.peg[vI],
-          peer
-        )
-      }
-    }
-
-    upeer = norm(upeer)
-
-    // console.log('CONJUNCT upeer', this.id, mark, this.done, done, upeer.map(p => p.canon))
-
-    upeer.sort((a: Val, b: Val) => {
-      return (a.constructor.name === b.constructor.name) ? 0 :
-        (a.constructor.name < b.constructor.name ? -1 : 1)
-    })
-
-    // console.log('CONJUNCT upeer sort', this.id, mark, this.done, done, upeer.map(p => p.canon))
-
-    // Unify terms against each other
-
-    let outvals: Val[] = []
-    let val: Val
-
-
-    // for (let pI = 0; pI < upeer.length; pI++) {
-    //   let pt = upeer[pI]
-    //   for (let qI = pI; qI < upeer.length; qI++) {
-    //     let qt = upeer[pI]
-
-    //     let pq = unite(ctx, pt, qt, 'cj-pq')
-
-    //   }
-    // }
-
-
-    // console.log('CJ upeer', mark, upeer.map(v => v.canon))
-
-    let t0 = upeer[0]
-
-    next_term:
-    for (let pI = 0; pI < upeer.length; pI++) {
-      // console.log('CJ TERM t0', pI, t0.done, t0.canon)
-
-      if (DONE !== t0.done) {
-        let u0 = unite(ctx, t0, TOP, 'cj-peer-t0')
-
-        if (
-          DONE !== u0.done
-
-          // Maps and Lists are still unified so that path refs will work
-          // TODO: || ListVal - test!
-          && !(
-            u0 instanceof MapVal
-            || u0 instanceof ListVal
-            || u0 instanceof RefVal
-          )
-        ) {
-
-          // 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 {
-          t0 = u0
-        }
-      }
-
-      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 if (t1 instanceof RefVal && !(t0 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, '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
-          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)
-
-        // pI++
-      }
-    }
-
-    // console.log('CJ outvals', mark, outvals.map(v => v.canon))
-
-    let out: Val
-
-    if (0 === outvals.length) {
-
-      // Empty conjuncts evaporate.
-      out = TOP
-    }
-
-    // TODO: corrects CV[CV[1&/x]] issue above, but swaps term order!
-    else if (1 === outvals.length) {
-      out = outvals[0]
-    }
-    else {
-      out = new ConjunctVal({ peg: outvals }, ctx)
-    }
-
-    out.done = done ? DONE : this.done + 1
-
-    // 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 this.peg.map((v: Val) => {
-      return (v as any).isBinaryOp && Array.isArray(v.peg) && 1 < v.peg.length ?
-        '(' + v.canon + ')' : v.canon
-    }).join('&')
-  }
-
-
-  gen(ctx?: Context) {
-    // Unresolved conjunct cannot be generated, so always an error.
-    let nil = Nil.make(
-      ctx,
-      'conjunct',
-      this, // (formatPath(this.peg, this.absolute) as any),
-      undefined
-    )
-
-    // TODO: refactor to use Site
-    nil.path = this.path
-    nil.url = this.url
-    nil.row = this.row
-    nil.col = this.col
-
-    descErr(nil, ctx)
-
-    if (ctx) {
-      ctx.err.push(nil)
-    }
-    else {
-      throw new Error(nil.msg)
-    }
-
-    return undefined
-  }
-}
-
-
-// Normalize Conjuct:
-// - flatten child conjuncts
-function norm(terms: Val[]): Val[] {
-
-  let expand: Val[] = []
-  for (let tI = 0, pI = 0; tI < terms.length; tI++, pI++) {
-    if (terms[tI] instanceof ConjunctVal) {
-      expand.push(...terms[tI].peg)
-      pI += terms[tI].peg.length - 1
-    }
-    else {
-      expand[pI] = terms[tI]
-    }
-  }
-
-  return expand
-}
-
-
-export {
-  norm,
-  ConjunctVal,
-}