aontu 0.29.0 → 0.30.2

package/src/val/PathFuncVal.ts

@@ -0,0 +1,75 @@
+/* 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 { RefVal } from '../val/RefVal'
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class PathFuncVal extends FuncBaseVal {
+  isPathFunc = true
+
+  prepared = 0
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    const pathfunc = new PathFuncVal(spec)
+    pathfunc.prepared = this.prepared
+    return pathfunc
+  }
+
+  funcname() {
+    return 'path'
+  }
+
+
+  prepare(ctx: AontuContext, args: Val[]) {
+    let arg = args[0]
+
+    if (0 === this.prepared) {
+      if (arg.isScalar) {
+        arg = this.place(new RefVal({ peg: [arg], absolute: false }))
+      }
+      else if (!arg.isRef) {
+        arg = makeNilErr(ctx, 'invalid-arg', this)
+      }
+    }
+
+    args[0] = arg
+
+    this.prepared++
+
+    return args
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+
+    return out
+  }
+
+}
+
+
+export {
+  PathFuncVal,
+}

package/src/val/PlusOpVal.ts

@@ -0,0 +1,92 @@
+/* Copyright (c) 2024-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+
+import { IntegerVal } from '../val/IntegerVal'
+import { NumberVal } from '../val/NumberVal'
+import { StringVal } from '../val/StringVal'
+import { BooleanVal } from '../val/BooleanVal'
+import { OpBaseVal } from './OpBaseVal'
+
+
+class PlusOpVal extends OpBaseVal {
+  isPlusOp = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new PlusOpVal(spec)
+  }
+
+  opname() {
+    return 'plus'
+  }
+
+
+  operate(_ctx: AontuContext, args: Val[]) {
+    let a: any = this.primatize(args[0]?.peg)
+    let b: any = this.primatize(args[1]?.peg)
+
+    let peg = undefined
+    if (undefined === a && undefined !== b) {
+      peg = b
+    }
+    else if (undefined === b && undefined !== a) {
+      peg = a
+    }
+    else {
+      const at = typeof a
+      const bt = typeof b
+      if ('boolean' === at && 'boolean' === bt) {
+        peg = a || b
+      }
+      else {
+        peg = a + b
+      }
+    }
+
+    let pegtype = typeof peg
+
+    let out = undefined
+
+    if ('string' === pegtype) {
+      out = new StringVal({ peg })
+    }
+    else if ('boolean' === pegtype) {
+      out = new BooleanVal({ peg })
+    }
+    else if ('number' === pegtype) {
+      out = Number.isInteger(peg) ? new IntegerVal({ peg }) : new NumberVal({ peg })
+    }
+
+    return out
+  }
+
+
+  get canon() {
+    return this.peg[0]?.canon + '+' + this.peg[1]?.canon
+  }
+
+}
+
+
+export {
+  PlusOpVal,
+}

package/src/val/PrefFuncVal.ts

@@ -0,0 +1,73 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import {
+  walk
+} from '../utility'
+
+import { NilVal } from '../val/NilVal'
+import { PrefVal } from '../val/PrefVal'
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class PrefFuncVal extends FuncBaseVal {
+  isPrefFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new PrefFuncVal(spec)
+  }
+
+  funcname() {
+    return 'pref'
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+
+    if (!out.isNil) {
+      out = out.clone(ctx)
+
+      // Wrap every child val in a PrefVal
+      out = walk(out, (_key: string | number | undefined, val: Val) => {
+        let oval = val
+        // console.log('PREFVAL', _key, oval.canon, oval.constructor.name)
+        if (
+          val.isScalar
+          || val.isPref
+        ) {
+          oval = new PrefVal({ peg: val }, ctx)
+        }
+
+        return oval
+      })
+    }
+
+    return out
+  }
+
+}
+
+
+export {
+  PrefFuncVal,
+}

package/src/val/PrefVal.ts

@@ -0,0 +1,159 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import { AontuContext } from '../ctx'
+import { unite } from '../unify'
+import { AontuError } from '../err'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+
+import { top } from './top'
+
+import { FeatureVal } from './FeatureVal'
+
+
+class PrefVal extends FeatureVal {
+  isPref = true
+
+  superpeg: Val
+  rank: number = 0
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    // this.pref = spec.pref || spec.peg
+
+    // this.superpeg = makeSuper(spec.peg)
+
+    if (spec.peg instanceof PrefVal) {
+      this.rank = 1 + spec.peg.rank
+    }
+
+    this.superpeg = this.peg.superior()
+    // console.log('PVC', this.peg.canon, this.superpeg.canon)
+  }
+
+
+  // PrefVal unify always returns a PrefVal
+  // PrefVals can only be removed by becoming Nil in a Disjunct
+  unify(peer: Val, ctx: AontuContext): Val {
+    peer = peer ?? top()
+
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Pref', this, peer)
+    let done = true
+    let out: Val = this
+    let why = ''
+
+
+    if (!this.peg.done) {
+      const resolved = unite(ctx.clone({ explain: ec(te, 'RES') }), this.peg, top(), 'pref/resolve')
+      // console.log('PREF-RESOLVED', this.peg.canon, '->', resolved)
+      this.peg = resolved
+    }
+
+
+    if (peer instanceof PrefVal) {
+      why += 'pref-'
+      if (this.rank < peer.rank) {
+        out = this
+        why += 'rank-win'
+      }
+      else if (peer.rank < this.rank) {
+        out = peer
+        why += 'rank-lose'
+      }
+      else {
+        let peg = unite(ctx.clone({ explain: ec(te, 'PEER') }), this.peg, peer.peg, 'pref-peer/' + this.id)
+        out = new PrefVal({ peg }, ctx)
+        why += 'rank-same'
+      }
+    }
+    else if (!peer.isTop) {
+      why += 'super-'
+
+      // if (this.superpeg instanceof Nil) {
+      //   out = peer
+      //   why += 'nil'
+      // }
+      // else {
+      //   why += 'unify'
+
+      out = unite(ctx.clone({ explain: ec(te, 'SUPER') }), this.superpeg, peer, 'pref-super/' + this.id)
+      if (out.same(this.superpeg)) {
+        out = this.peg
+        why += 'same'
+      }
+
+      // }
+    }
+    else {
+      why += 'none'
+    }
+
+    out.dc = done ? DONE : this.dc + 1
+
+    // console.log('PREFVAL-OUT', why, this.canon, peer.canon, '->', out.canon, out.done)
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    if (null == peer) {
+      return false
+    }
+
+    let pegsame = (this.peg === peer.peg) ||
+      (this.peg.isVal && this.peg.same(peer.peg))
+
+    return pegsame
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as PrefVal)
+    // out.pref = this.pref.clone(null, ctx)
+    return out
+  }
+
+
+  get canon() {
+    // return this.pref instanceof Nil ? this.peg.canon : '*' + this.pref.canon
+    return '*' + this.peg.canon
+  }
+
+
+  gen(ctx?: AontuContext) {
+    let val = this.peg
+
+    if (val.isNil) {
+      if (null == ctx) {
+        throw new AontuError(val.msg)
+      }
+    }
+
+    return val.gen(ctx)
+  }
+}
+
+
+export {
+  PrefVal,
+}