aontu 0.29.0 → 0.30.2

package/src/val/FuncBaseVal.ts

@@ -0,0 +1,198 @@
+/* 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 {
+  propagateMarks,
+  ec,
+  explainClose,
+  explainOpen,
+} from '../utility'
+
+import { makeNilErr, AontuError } from '../err'
+
+import {
+  top
+} from './top'
+
+import { NilVal } from '../val/NilVal'
+import { ConjunctVal } from '../val/ConjunctVal'
+import { FeatureVal } from '../val/FeatureVal'
+
+
+class FuncBaseVal extends FeatureVal {
+  isFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    // console.log('FBV', this.id, this.constructor.name, this.peg?.[0]?.canon)
+  }
+
+
+  validateArgs(args: Val[], min: number) {
+    if (min < args.length) {
+      // TODO: this is an error as as a parse error, needs to be handled same way
+      throw new AontuError('The ' + this.funcname() + ' function needs at least ' +
+        min + ' argument' + (1 === min ? '' : 's') + '.')
+    }
+  }
+
+
+  make(ctx: AontuContext, _spec: ValSpec): Val {
+    return makeNilErr(ctx, 'func:' + this.funcname(), this, undefined, 'make')
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Func:' + this.funcname(), this, peer)
+
+    // const sc = this.id + '=' + this.canon
+    // const pc = peer.id + '=' + peer.canon
+
+
+    let why = ''
+    let out: Val = this
+
+
+    // console.log('FBV', this.id, this.constructor.name, this.mark.type, this.peg?.canon, 'PEER', peer.id, peer.canon)
+
+    if (this.id !== peer.id) {
+
+      if (peer.isTop && (this.mark.type || this.mark.hide)) {
+        this.dc = DONE
+      }
+
+      else {
+        let pegdone = true
+        let newpeg: Val[] = []
+        let newtype = this.mark.type
+        let newhide = this.mark.hide
+
+        this.peg = this.prepare(ctx, this.peg)
+
+        for (let arg of this.peg) {
+          // console.log('FUNCBASE-UNIFY-PEG-A', arg.canon)
+
+          let newarg = arg
+          if (!arg.done) {
+            newarg = arg.unify(top(), ctx.clone({ explain: ec(te, 'ARG') }))
+            newtype = newtype || newarg.mark.type
+            newhide = newhide || newarg.mark.hide
+            // console.log('FUNCBASE-UNIFY-PEG-B', arg.canon, '->', newarg.canon)
+          }
+          pegdone &&= arg.done
+          newpeg.push(newarg)
+        }
+
+        // console.log('FUNCBASE-PEG', this.id, pegdone, this.peg.map((p: any) => p?.canon))
+
+        if (pegdone) {
+          const resolved = this.resolve(ctx, newpeg)
+          // console.log('FUNC-RESOLVED', ctx.cc, resolved?.canon)
+
+          out = resolved.done && peer.isTop ? resolved :
+            unite(ctx.clone({ explain: ec(te, 'PEG') }), resolved, peer, 'func-' + this.funcname() + '/' + this.id)
+          propagateMarks(this, out)
+
+          // const unified =
+          //   unite(ctx, resolved, peer, 'func-' + this.funcname() + '/' + this.id)
+          // out = unified
+          // propagateMarks(unified, out)
+          // propagateMarks(this, out)
+
+          // TODO: make should handle this using ctx?
+          out.site.row = this.site.row
+          out.site.col = this.site.col
+          out.site.url = this.site.url
+          out.path = this.path
+
+          why += 'pegdone'
+        }
+        else if (peer.isTop) {
+          this.notdone()
+          out = this.make(ctx, { peg: newpeg, mark: { type: newtype, hide: newhide } })
+
+          // TODO: make should handle this using ctx?
+          out.site.row = this.site.row
+          out.site.col = this.site.col
+          out.site.url = this.site.url
+          out.path = this.path
+
+          why += 'top'
+        }
+        else if (peer.isNil) {
+          this.notdone()
+          out = peer
+          why += 'nil'
+        }
+        else {
+          this.notdone()
+          out = new ConjunctVal({
+            peg: [this, peer], mark: { type: newtype, hide: newhide }
+          }, ctx)
+
+          // TODO: make should handle this using ctx?
+          out.site.row = this.site.row
+          out.site.col = this.site.col
+          out.site.url = this.site.url
+          out.path = this.path
+
+          why += 'defer'
+        }
+      }
+    }
+
+    // console.log('FUNC-UNIFY-OUT', this.funcname(), this.id, this.canon, 'W=', why, peer.id, peer.canon, 'O=', out.dc, out.id, out.canon)
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+
+  get canon() {
+    return '' +
+      // (this.type ? '<type>' : '') +
+      // (this.done ? '<done>' : '') +
+      // (this.id + '=') +
+      this.funcname() + '(' + (this.peg.map((p: any) => p.canon).join(',')) + ')'
+  }
+
+
+  funcname() {
+    return 'func'
+  }
+
+
+  prepare(_ctx: AontuContext | undefined, args: Val[]): Val[] {
+    return args
+  }
+
+
+  resolve(ctx: AontuContext | undefined, _args: Val[]): Val {
+    return makeNilErr(ctx, 'func:' + this.funcname(), this, undefined, 'resolve')
+  }
+
+
+}
+
+
+export {
+  FuncBaseVal,
+}

package/src/val/HideFuncVal.ts

@@ -0,0 +1,85 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+
+import {
+  walk,
+  explainOpen,
+  explainClose,
+} from '../utility'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class HideFuncVal extends FuncBaseVal {
+  isHideFunc = true
+
+  resolved?: Val
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+
+    // The function does not mark itself!
+    this.mark.type = false
+    this.mark.hide = false
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new HideFuncVal(spec)
+  }
+
+  funcname() {
+    return 'hide'
+  }
+
+
+  /*
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'HideFunc', this, peer)
+    let out: Val | undefined = this.resolved
+
+    if (null == out) {
+      out = this.resolve(ctx, this.peg)
+    }
+
+    explainClose(te, out)
+    return out
+  }
+  */
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+    if (!out.isNil) {
+      out = out.clone(ctx)
+
+      walk(out, (_key: string | number | undefined, val: Val) => {
+        val.mark.hide = true
+        return val
+      })
+    }
+
+    return out
+  }
+}
+
+
+export {
+  HideFuncVal,
+}

package/src/val/IntegerVal.ts

@@ -0,0 +1,75 @@
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr, AontuError } from '../err'
+
+import { ScalarVal } from './ScalarVal'
+import { Integer } from './ScalarKindVal'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+
+class IntegerVal extends ScalarVal {
+  isInteger = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    if (!Number.isInteger(spec.peg)) {
+      // TODO: use Nil?
+      throw new AontuError('not-integer: ' + spec.peg)
+    }
+    // super({ peg: spec.peg, kind: Integer }, ctx)
+    super({ ...spec, kind: Integer }, ctx)
+  }
+
+  unify(peer: any, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Integer', this, peer)
+
+    let out: Val = this
+
+    if (null != peer) {
+      if (peer.isScalarKind) {
+        out = peer.unify(this, ctx.clone({ explain: ec(te, 'KND') }))
+      }
+      else if (
+        peer.isScalar &&
+        peer.peg === this.peg
+      ) {
+        out = this
+      }
+      else if (peer.isTop) {
+        out = this
+      }
+      else {
+        out = makeNilErr(ctx, 'scalar_' +
+          ((peer as any).kind === this.kind ? 'value' : 'kind'), this, peer)
+      }
+    }
+    else {
+      out = super.unify(peer, ctx)
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+}
+
+
+export {
+  IntegerVal,
+}

package/src/val/JunctionVal.ts

@@ -0,0 +1,54 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { FeatureVal } from './FeatureVal'
+
+
+// Abstract base class for binary operations that work with arrays of Val objects
+// (ConjunctVal and DisjunctVal)
+abstract class JunctionVal extends FeatureVal {
+  isJunction = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+  // NOTE: mutation!
+  append(peer: Val): JunctionVal {
+    this.peg.push(peer)
+    return this
+  }
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as JunctionVal)
+    out.peg = this.peg.map((entry: Val) => entry.clone(ctx, spec?.mark ? { mark: spec.mark } : {}))
+    return out
+  }
+
+  get canon() {
+    return this.peg.map((v: Val) => {
+      return (v as any).isJunction && Array.isArray(v.peg) && 1 < v.peg.length ?
+        '(' + v.canon + ')' : v.canon
+    }).join(this.getJunctionSymbol())
+  }
+
+  // Abstract method to be implemented by subclasses to define their junction symbol
+  abstract getJunctionSymbol(): string
+}
+
+
+export {
+  JunctionVal,
+}

package/src/val/KeyFuncVal.ts

@@ -0,0 +1,67 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { StringVal } from '../val/StringVal'
+
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class KeyFuncVal extends FuncBaseVal {
+  isKeyFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    // this.dc = DONE
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new KeyFuncVal(spec)
+  }
+
+  funcname() {
+    return 'key'
+  }
+
+
+
+  resolve(_ctx: AontuContext, _args: Val[]) {
+    let out: Val = this
+
+    if (!this.mark.type && !this.mark.hide) {
+      let move = this.peg?.[0]?.peg
+      move = isNaN(move) ? 1 : +move
+      const key = this.path[this.path.length - (1 + move)] ?? ''
+
+      out = new StringVal({ peg: key })
+    }
+
+    return out
+  }
+
+
+  gen(_ctx: AontuContext): any {
+    return undefined
+  }
+
+}
+
+
+export {
+  KeyFuncVal,
+}