aontu 0.30.1 → 0.30.2

package/src/val/ConjunctVal.ts

@@ -0,0 +1,285 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import { AontuContext } from '../ctx'
+
+import { makeNilErr } from '../err'
+import { unite } from '../unify'
+
+import {
+  AontuError
+} from '../err'
+
+
+import { JunctionVal } from './JunctionVal'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+  propagateMarks,
+} from '../utility'
+
+
+
+import {
+  top
+} from './top'
+
+
+const CONJUNCT_ORDERING: Record<string, number> = {
+  PrefVal: 30000,
+  RefVal: 32500,
+  DisjunctVal: 35000,
+  ConjunctVal: 40000,
+  Any: 99999
+}
+
+
+
+// TODO: move main logic to op/conjunct
+class ConjunctVal extends JunctionVal {
+  isConjunct = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.mark.type = !!spec.mark?.type
+    this.mark.hide = !!spec.mark?.hide
+    this.peg = (Array.isArray(this.peg) ? this.peg : [])
+      .filter((p: Val) => null != p && p.isVal)
+    this.peg?.map((v: Val) => {
+      propagateMarks(this, v)
+      return v
+    })
+    // console.log('CONJUNCT-ctor', this.peg.map((v: Val) => v.canon))
+  }
+
+  // NOTE: mutation!
+  append(peer: Val): ConjunctVal {
+    super.append(peer)
+    propagateMarks(this, peer)
+    return this
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    peer = peer ?? top()
+
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Conjunct', this, peer)
+
+    let done = true
+
+    this.peg = norm(this.peg)
+
+
+    // Unify each term of conjunct against peer
+    let upeer: Val[] = []
+
+    let newtype = this.mark.type || peer.mark.type
+    let newhide = this.mark.hide || peer.mark.hide
+
+    for (let vI = 0; vI < this.peg.length; vI++) {
+      newtype = this.peg[vI].mark.type || newtype
+      newhide = this.peg[vI].mark.hide || newhide
+    }
+
+    for (let vI = 0; vI < this.peg.length; vI++) {
+      this.peg[vI].mark.type = newtype
+      this.peg[vI].mark.hide = newhide
+      // console.log('CONJUNCT-TERM', this.id, vI, this.peg[vI].canon)
+
+      upeer[vI] = (this.peg[vI].done && peer.isTop) ? this.peg[vI] :
+        unite(ctx.clone({ explain: ec(te, 'OWN') }), this.peg[vI], peer, 'cj-own')
+      upeer[vI].mark.type = newtype = newtype || upeer[vI].mark.type
+      upeer[vI].mark.hide = newhide = newhide || upeer[vI].mark.hide
+
+      // let prevdone = done
+      done = done && (DONE === upeer[vI].dc)
+
+      if (upeer[vI].isNil) {
+        return upeer[vI]
+        // return Nil.make(
+        //   ctx,
+        //   '&peer[' + upeer[vI].canon + ',' + peer.canon + ']',
+        //   this.peg[vI],
+        //   peer
+        // )
+      }
+    }
+
+    upeer = norm(upeer)
+    // console.log('CONJUNCT-UPEER', this.id, upeer.map((v: Val) => v.canon))
+
+    // Unify terms against each other
+
+    let outvals: Val[] = []
+    let val: Val
+
+
+    let t0 = upeer[0]
+
+    // next_term:
+    for (let pI = 0; pI < upeer.length; pI++) {
+      let t1 = upeer[pI + 1]
+
+      // console.log('CONJUNCT-TERMS-C', this.id, pI, t0, t1, 'OV=', outvals.map((v: Val) => v))
+
+      if (null == t1) {
+        outvals.push(t0)
+        newtype = this.mark.type || t0.mark.type
+        newhide = this.mark.hide || t0.mark.hide
+      }
+
+      // Can't unite with a RefVal, unless also a RefVal with same path.
+      // else if (t0 instanceof RefVal && !(t1 instanceof RefVal)) {
+      else if (t0.isRef && !(t1.isRef)) {
+        outvals.push(t0)
+        t0 = t1
+      }
+
+      else if (t1.isRef && !(t0.isRef)) {
+        outvals.push(t0)
+        t0 = t1
+      }
+
+
+      else {
+        val = unite(ctx.clone({ explain: ec(te, 'DEF') }), t0, t1, 'cj-peer-t0t1')
+        done = done && DONE === val.dc
+        newtype = this.mark.type || val.mark.type
+        newhide = this.mark.hide || val.mark.hide
+
+        // Unite was just a conjunt anyway, so discard.
+        if (val.isConjunct) {
+          outvals.push(t0)
+          t0 = t1
+        }
+        else if (val.isNil) {
+          return val
+        }
+        else {
+          t0 = val
+        }
+        // TODO: t0 should become this to avoid unnecessary repasses
+        // outvals.push(val)
+
+        // pI++
+      }
+    }
+
+    let out: Val
+
+    // console.log('CONJUCT-prepout', this.id, outvals.map((v: Val) => v.canon))
+
+    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]
+      out.mark.type = newtype
+      out.mark.hide = newhide
+    }
+    else {
+      out = new ConjunctVal({ peg: outvals, mark: { type: newtype, hide: newhide } }, ctx)
+    }
+
+    out.dc = done ? DONE : this.dc + 1
+
+    // console.log('CONJUNCT-unify', this.id, sc, pc, '->', out.canon, 'D=' + out.dc, 'E=', this.err)
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as ConjunctVal)
+    return out
+  }
+
+
+  getJunctionSymbol(): string {
+    return '&'
+  }
+
+
+  gen(ctx?: AontuContext) {
+    // Unresolved conjunct cannot be generated, so always an error.
+    let nil = makeNilErr(
+      ctx,
+      'conjunct',
+      this, // (formatPath(this.peg, this.absolute) as any),
+      undefined
+    )
+
+    // TODO: refactor to use Site
+    nil.path = this.path
+    nil.site.url = this.site.url
+    nil.site.row = this.site.row
+    nil.site.col = this.site.col
+
+    // descErr(nil, ctx)
+
+    if (null == ctx) {
+      throw new AontuError(nil.msg)
+    }
+
+    return undefined
+  }
+}
+
+
+
+// Normalize Conjunct:
+// - flatten child conjuncts
+// - consistent sorting of terms
+function norm(terms: Val[]): Val[] {
+
+  let expand: Val[] = []
+  for (let tI = 0, pI = 0; tI < terms.length; tI++, pI++) {
+    if (terms[tI].isConjunct) {
+      expand.push(...terms[tI].peg)
+      pI += terms[tI].peg.length - 1
+    }
+    else {
+      expand[pI] = terms[tI]
+    }
+  }
+
+
+  // Consistent ordering ensures order independent unification.
+  expand = expand.sort((a: Val, b: Val) => {
+    const an = CONJUNCT_ORDERING[a.constructor.name] ?? CONJUNCT_ORDERING.Any
+    const bn = CONJUNCT_ORDERING[b.constructor.name] ?? CONJUNCT_ORDERING.Any
+    return an - bn
+  })
+
+  // console.log('NORM', expand.map(t => t.canon).join(', '))
+
+
+  return expand
+}
+
+
+export {
+  norm,
+  ConjunctVal,
+}

package/src/val/CopyFuncVal.ts

@@ -0,0 +1,69 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import { NilVal } from '../val/NilVal'
+
+
+import {
+  walk
+} from '../utility'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class CopyFuncVal extends FuncBaseVal {
+  isCopyFunc = true
+
+  resolved?: Val
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.mark.type = false
+    this.mark.hide = false
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new CopyFuncVal(spec)
+  }
+
+  funcname() {
+    return 'copy'
+  }
+
+  resolve(ctx: AontuContext | undefined, args: Val[]) {
+    const val = args?.[0]
+    const out = null == val || null == ctx ?
+      makeNilErr(ctx, 'invalid-arg', this) :
+      val.clone(ctx, { mark: { type: false, hide: false } })
+
+    walk(out, (_key: string | number | undefined, val: Val) => {
+      val.mark.type = false
+      val.mark.hide = false
+      return val
+    })
+
+    return out
+  }
+}
+
+
+export {
+  CopyFuncVal,
+}

package/src/val/DisjunctVal.ts

@@ -0,0 +1,288 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import { AontuContext } from '../ctx'
+
+import { makeNilErr } from '../err'
+import { unite } from '../unify'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+import {
+  Site
+} from '../site'
+
+import {
+  top
+} from './top'
+
+import { NilVal } from '../val/NilVal'
+import { PrefVal } from '../val/PrefVal'
+import { JunctionVal } from '../val/JunctionVal'
+
+
+
+// TODO: move main logic to op/disjunct
+class DisjunctVal extends JunctionVal {
+  isDisjunct = true
+
+  prefsRanked = false
+
+  // TODO: sites from normalization of orginal Disjuncts, as well as child pegs
+  constructor(
+    spec: {
+      peg: Val[]
+    },
+    ctx?: AontuContext,
+    _sites?: Site[]
+  ) {
+    super(spec, ctx)
+  }
+
+
+  // NOTE: mutation!
+  append(peer: Val): DisjunctVal {
+    super.append(peer)
+    this.prefsRanked = false
+    return this
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    peer = peer ?? top()
+
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Disjunct', this, peer)
+
+    if (!this.prefsRanked) {
+      this.rankPrefs(ctx)
+    }
+
+    // // // console.log('DISJUNCT-unify-A', this.id, this.canon)
+
+    let done = true
+
+    let oval: Val[] = []
+
+    // Conjunction (&) distributes over disjunction (|)
+    for (let vI = 0; vI < this.peg.length; vI++) {
+      const v = this.peg[vI]
+      const cloneCtx = ctx?.clone({ err: [] })
+
+      // // // console.log('DJ-DIST-A', this.peg[vI].canon, peer.canon)
+      oval[vI] = unite(cloneCtx.clone({ explain: ec(te, 'DIST:' + vI) }), v, peer, 'dj-peer')
+      // // // console.log('DJ-DIST-B', oval[vI].canon, cloneCtx?.err)
+
+      if (0 < cloneCtx?.err.length) {
+        oval[vI] = makeNilErr(cloneCtx, '|:empty-dist', this)
+      }
+
+      done = done && DONE === oval[vI].dc
+    }
+
+    // // // console.log('DISJUNCT-unify-B', this.id, oval.map(v => v.canon))
+
+    // Remove duplicates, and normalize
+    if (1 < oval.length) {
+      for (let vI = 0; vI < oval.length; vI++) {
+        if (oval[vI].isDisjunct) {
+          oval.splice(vI, 1, ...oval[vI].peg)
+        }
+      }
+
+      // // // console.log('DISJUNCT-unify-C', this.id, oval.map(v => v.id + '=' + v.canon))
+
+      // TODO: not an error Nil!
+      let remove = new NilVal()
+      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('DISJUNCT-unify-D', this.id, oval.map(v => v.canon))
+
+      oval = oval.filter(v => !v.isNil)
+    }
+
+    let out: Val
+
+    if (1 == oval.length) {
+      out = oval[0]
+    }
+    else if (0 == oval.length) {
+      return makeNilErr(ctx, '|:empty', this, peer)
+    }
+    else {
+      out = new DisjunctVal({ peg: oval }, ctx)
+    }
+
+    out.dc = done ? DONE : this.dc + 1
+
+    // // // console.log('DISJUNCT-unify',
+    //   this.id, sc, pc, '->', out.canon, 'D=' + out.dc, 'E=', this.err)
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  rankPrefs(ctx: AontuContext) {
+    let lastpref: PrefVal | undefined = undefined
+    let lastprefI = -1
+
+    // // // console.log('RP-A', this.peg.map((p: Val) => p.canon))
+
+    for (let vI = 0; vI < this.peg.length; vI++) {
+      const v = this.peg[vI]
+      if (v instanceof PrefVal) {
+        if (null != lastpref) {
+          if (v.rank === lastpref.rank) {
+            const pref = v.unify(lastpref, ctx) as PrefVal
+            if (pref.isNil) {
+              return pref
+            }
+            else {
+              this.peg[lastprefI] = pref
+              lastpref = pref
+              this.peg[vI] = null
+            }
+            // return Nil.make(ctx, '|:prefs', lastpref, v, 'associate')
+          }
+          else if (v.rank < lastpref.rank) {
+            this.peg[lastprefI] = null
+            lastpref = v
+            lastprefI = vI
+          }
+          else {
+            this.peg[vI] = null
+          }
+        }
+        else {
+          lastpref = v
+          lastprefI = vI
+        }
+      }
+      else if (v.isDisjunct) {
+        let subrank: any = v.rankPrefs(ctx)
+        if (subrank instanceof PrefVal) {
+          this.peg[vI] = subrank
+          lastpref = subrank
+          lastprefI = vI
+        }
+      }
+    }
+
+    this.peg = this.peg.filter((p: any) => null != p)
+    this.prefsRanked = true
+
+    // // // console.log('RP-Z', this.peg.map((p: Val) => p.canon))
+
+    if (1 === this.peg.length && this.peg[0] instanceof PrefVal) {
+      return this.peg[0]
+    }
+  }
+
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as DisjunctVal)
+    return out
+  }
+
+
+  getJunctionSymbol(): string {
+    return '|'
+  }
+
+
+  gen(ctx: AontuContext) {
+    // TODO: move this to main unify
+
+    // console.log('DJ-GEN', this.peg.map((p: any) => p.canon), ctx.err)
+
+    if (0 < this.peg.length) {
+
+      let vals = this.peg.filter((v: Val) => v instanceof PrefVal)
+      // // // console.log('DJ-GEN-VALS-A', vals.map((p: any) => p.canon))
+
+      vals = 0 === vals.length ? this.peg : vals
+
+      let val = vals[0]
+
+      // TODO: over unifies complex types like maps
+      // ({x:1}|{y:2})&{z:3} should be {"x":1,"z":3}|{"y":2,"z":3} not { x:1, z:3, y:2 }
+      for (let vI = 1; vI < vals.length; vI++) {
+        let valnext = val.unify(this.peg[vI], ctx)
+        // // // console.log('DJ-GEN-VALS-NEXT', valnext.canon)
+        val = valnext
+      }
+
+      // console.log('DJ-GEN-VALS-B', val.canon)
+      const out = val.gen(ctx)
+      // console.log('DJ-GEN-VALS-C', out)
+      return out
+    }
+
+    return super.gen(ctx)
+
+    // // // console.log('DJ-GEN', this.peg)
+
+    // if (1 === this.peg.length) {
+    //   return this.peg[0].gen(ctx)
+    // }
+    // else if (1 < this.peg.length) {
+    //   let peg = this.peg.filter((v: Val) => v instanceof PrefVal)
+
+    //   if (1 === peg.length) {
+    //     return peg[0].gen(ctx)
+    //   }
+    //   else {
+
+    //     let nil = Nil.make(
+    //       ctx,
+    //       'disjunct',
+    //       this,
+    //       undefined
+    //     )
+
+    //     // TODO: refactor to use Site
+    //     nil.path = this.path
+    //     nil.site.url = this.url
+    //     nil.site.row = this.row
+    //     nil.site.col = this.col
+
+    //     // descErr(nil, ctx)
+
+    //     if (null == ctx) {
+    //       throw new Error(nil.msg)
+    //     }
+    //   }
+
+    //   return undefined
+    // }
+  }
+}
+
+
+
+
+export {
+  DisjunctVal,
+}

package/src/val/FeatureVal.ts

@@ -0,0 +1,56 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+import { Val } from './Val'
+
+import { top } from './top'
+
+import { AontuError, descErr, makeNilErr } from '../err'
+
+
+abstract class FeatureVal extends Val {
+  isFeature = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  superior(): Val {
+    return top()
+  }
+
+
+  gen(ctx: AontuContext) {
+    // Unresolved nil cannot be generated, so always an error.
+
+    let nerr = makeNilErr(ctx, 'no_gen', this)
+    descErr(nerr, ctx)
+    ctx?.adderr(nerr)
+
+    if (null == ctx || !ctx?.collect) {
+      const aerr = new AontuError(nerr.msg, [nerr])
+      throw aerr
+    }
+
+    return undefined
+  }
+
+}
+
+
+export {
+  FeatureVal,
+}