aontu 0.30.1 → 0.30.2

package/src/val/MoveFuncVal.ts

@@ -0,0 +1,79 @@
+/* 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'
+import { CopyFuncVal } from './CopyFuncVal'
+
+
+
+class MoveFuncVal extends FuncBaseVal {
+  isMoveFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new MoveFuncVal(spec)
+  }
+
+  funcname() {
+    return 'move'
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+
+    const orig = out
+    const origcanon = orig.canon
+
+    if (!orig.isNil) {
+      const src = orig.clone(ctx)
+
+      walk(orig, (_key: string | number | undefined, val: Val) => {
+        val.mark.hide = true
+        return val
+      })
+
+      out = new CopyFuncVal({ peg: [src] }, ctx)
+    }
+
+    Object.defineProperty(out, 'canon', {
+      get: () => 'move(' + origcanon + ')',
+      configurable: true
+    })
+
+    // console.log('MOVE-resolve', out)
+
+    return out
+  }
+}
+
+
+export {
+  MoveFuncVal,
+}

package/src/val/NilVal.ts

@@ -0,0 +1,156 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+import { Val } from './Val'
+
+import { AontuError, descErr } from '../err'
+
+
+class NilVal extends Val {
+  isNil = true
+
+  nil = true
+  why: any
+  primary?: Val
+  secondary?: Val
+  msg: string = ''
+  attempt?: string
+
+  // TODO: include Val generating nil, thus capture type
+
+  // A Nil is an error - should not happen - unify failed
+  // refactor ,make(spec,ctx)
+  static make = (ctx?: AontuContext, why?: any, av?: Val, bv?: Val, attempt?: string) => {
+    let nil = new NilVal({ why }, ctx)
+
+    nil.attempt = attempt
+    // TODO: this should be done lazily, for multiple terms
+
+    // Terms later in same file are considered the primary error location.
+    if (null != av) {
+      nil.site.row = av.site.row
+      nil.site.col = av.site.col
+      nil.site.url = av.site.url
+
+      nil.primary = av
+
+      if (null != bv) {
+        nil.secondary = bv
+
+        let bv_loc_wins =
+          (nil.site.url === bv.site.url) && (
+            (nil.site.row < bv.site.row) ||
+            (nil.site.row === bv.site.row && nil.site.col < bv.site.col)
+          )
+
+        if (bv_loc_wins) {
+          nil.site.row = bv.site.row
+          nil.site.col = bv.site.col
+          nil.site.url = bv.site.url
+          nil.primary = bv
+          nil.secondary = av
+        }
+      }
+    }
+
+    if (ctx) {
+      ctx.adderr(nil)
+    }
+
+    return nil
+  }
+
+
+  constructor(
+    spec?: {
+      why?: string
+      msg?: string
+      err?: NilVal | NilVal[] | Error | Error[]
+    } | string,
+    ctx?: AontuContext
+  ) {
+    super(spec && 'string' !== typeof spec ? spec : {}, ctx)
+
+    if (spec && 'object' === typeof spec) {
+      this.why = spec?.why
+      this.msg = 'string' === typeof spec?.msg ? spec.msg : this.msg
+      this.err = spec ?
+        Array.isArray(spec.err) ? [...spec.err] :
+          null != spec.err ? [spec.err] :
+            [] : []
+    }
+
+    // Nil is always DONE, by definition.
+    this.dc = DONE
+  }
+
+
+  unify(_peer: Val, _ctx: AontuContext) {
+    return this
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as NilVal)
+    out.why = this.why
+
+    // Should these clone?
+    // out.primary = this.primary?.clone()
+    // out.secondary = this.secondary?.clone()
+    out.primary = this.primary
+    out.secondary = this.secondary
+
+    out.msg = this.msg
+    return out
+  }
+
+
+  // TODO: custom canon? useful for unknown function errors
+  get canon() {
+    return 'nil'
+  }
+
+
+  gen(ctx: AontuContext) {
+    // Unresolved nil cannot be generated, so always an error.
+
+    this.why = this.why ?? 'nil_gen'
+    ctx.adderr(this)
+
+    if (!ctx.collect) {
+      const err = new AontuError(this.msg, [this])
+      throw err
+    }
+
+    return undefined
+  }
+
+
+  superior(): Val {
+    return this
+  }
+
+
+  inspection() {
+    return this.why
+  }
+
+}
+
+
+export {
+  NilVal,
+}

package/src/val/NullVal.ts

@@ -0,0 +1,38 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { ScalarVal } from './ScalarVal'
+import { Null } from './ScalarKindVal'
+
+
+class NullVal extends ScalarVal {
+  isNull = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super({ peg: spec.peg, kind: Null }, ctx)
+    this.peg = null
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    return super.unify(peer, ctx)
+  }
+}
+
+
+export {
+  NullVal,
+}
+

package/src/val/NumberVal.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, AontuError } from '../err'
+
+import { ScalarVal } from './ScalarVal'
+
+import {
+  explainOpen,
+  explainClose,
+} from '../utility'
+
+
+
+class NumberVal extends ScalarVal {
+  isNumber = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    if (isNaN(spec.peg)) {
+      // TODO: use Nil?
+      throw new AontuError('not-number: ' + spec.peg)
+    }
+
+    super({ ...spec, kind: Number }, ctx)
+  }
+
+
+  unify(peer: any, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Number', this, peer)
+
+    let out: Val = this
+
+    if (null != peer) {
+      if (peer.isScalarKind) {
+        out = peer.unify(this, ctx)
+      }
+      else if (
+        peer.isScalar &&
+        peer.peg === this.peg
+      ) {
+        out = peer.isInteger ? peer : 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 {
+  NumberVal,
+}

package/src/val/OpBaseVal.ts

@@ -0,0 +1,231 @@
+/* Copyright (c) 2024 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  descErr,
+  makeNilErr,
+  AontuError
+} from '../err'
+
+import { AontuContext } from '../ctx'
+import { unite } from '../unify'
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+import {
+  top
+} from './top'
+
+import { ConjunctVal } from './ConjunctVal'
+import { FeatureVal } from './FeatureVal'
+
+
+
+
+class OpBaseVal extends FeatureVal {
+  isPlusOp = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.peg = []
+
+    for (let pI = 0; pI < spec.peg.length; pI++) {
+      this.append(spec.peg[pI])
+    }
+  }
+
+
+  append(part: any) {
+    this.peg.push(part)
+  }
+
+
+  make(ctx: AontuContext, _spec: ValSpec): Val {
+    return makeNilErr(ctx, 'op:' + this.opname(), this, undefined, 'make')
+  }
+
+  opname() {
+    return 'op'
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Op:' + this.opname(), this, peer)
+    let out: Val = this
+
+    if (this.id == peer.id) {
+      return this
+    }
+
+
+    let pegdone = true
+    let newpeg: Val[] = []
+
+    for (let arg of this.peg) {
+      if (!arg.done) {
+        arg = arg.unify(top(), ctx, ec(te, 'ARG'))
+      }
+      pegdone &&= arg.done
+      newpeg.push(arg)
+    }
+
+    // console.log('OPVAL', this.id, this.opname(), pegdone, newpeg.map(p => p.canon))
+
+    if (pegdone) {
+      let result: Val | undefined = null == ctx ? this : this.operate(ctx, newpeg)
+
+      result = result || this
+
+      if (null == result && this.canon === peer.canon) {
+        out = this
+      }
+
+      // TODO: should be result.isOp
+      else if (result instanceof OpBaseVal) {
+        if (peer.isTop) {
+          out = this
+        }
+        // TODO: should peer.isNil
+        else if (peer.isNil) {
+          out = makeNilErr(ctx, 'op[' + this.peg + ']', this, peer)
+        }
+
+        else if (this.canon === peer.canon) {
+          out = this
+        }
+
+        else {
+          this.dc = DONE === this.dc ? DONE : this.dc + 1
+          out = new ConjunctVal({ peg: [this, peer] }, ctx)
+        }
+      }
+      else {
+        out = result.done && peer.isTop ? result :
+          unite(ctx.clone({ explain: ec(te, 'RES') }), result, peer, 'op')
+      }
+
+      out.dc = DONE === out.dc ? DONE : this.dc + 1
+    }
+    else if (peer.isTop) {
+      this.notdone()
+      out = this.make(ctx, { peg: newpeg })
+
+      // 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] }, 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
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : this.peg === peer.peg
+  }
+
+
+  clone(ctx: AontuContext, _spec?: ValSpec): Val {
+    let out = (super.clone(ctx, {
+      peg: this.peg,
+    }) as OpBaseVal)
+    return out
+  }
+
+
+  operate(ctx: AontuContext, _args: Val[]): Val | undefined {
+    return makeNilErr(ctx, 'op:' + this.opname(), this, undefined, 'operate')
+  }
+
+
+  get canon() {
+    return 'op'
+  }
+
+
+  primatize(v: any): undefined | null | string | number | boolean {
+    const t = typeof v
+    if (null == v || 'string' === t || 'number' === t || 'boolean' === t) {
+      return v
+    }
+    else if (v?.isVal) {
+      return this.primatize(v.peg)
+    }
+    else if (v?.toString) {
+      return '' + v
+    }
+    else {
+      return undefined
+    }
+  }
+
+
+  gen(ctx?: AontuContext) {
+    // Unresolved op cannot be generated, so always an error.
+    let nil = makeNilErr(
+      ctx,
+      'op',
+      this,
+      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 (ctx) {
+      // ctx.err.push(nil)
+      ctx.adderr(nil)
+    }
+    else {
+      throw new AontuError(nil.msg)
+    }
+
+    return undefined
+  }
+}
+
+
+export {
+  OpBaseVal,
+}

package/src/val/OpenFuncVal.ts

@@ -0,0 +1,60 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+import { NilVal } from '../val/NilVal'
+import { BagVal } from '../val/BagVal'
+
+
+class OpenFuncVal extends FuncBaseVal {
+  isOpenFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new OpenFuncVal(spec)
+  }
+
+  funcname() {
+    return 'open'
+  }
+
+
+  resolve(ctx: AontuContext | undefined, args: Val[]) {
+    const argval: any = args[0]
+
+    if (null == argval) {
+      return makeNilErr(ctx, 'no_first_arg', this, undefined, 'close')
+    }
+
+    if (argval.isMap || argval.isList) {
+      (argval as BagVal).closed = false
+    }
+
+    return argval
+  }
+
+}
+
+
+export {
+  OpenFuncVal,
+}

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,
+}