aontu 0.29.0 → 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/{lib/val/Nil.ts → src/val/NilVal.ts}

@@ -1,8 +1,7 @@
-/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
 
 
 import type {
-  Val,
   ValSpec,
 } from '../type'
 
@@ -11,18 +10,16 @@ import {
 } from '../type'
 
 import {
-  descErr
-} from '../err'
+  AontuContext,
+} from '../ctx'
 
-import {
-  Context,
-} from '../unify'
 
+import { Val } from './Val'
 
-import { ValBase } from '../val/ValBase'
+import { AontuError, descErr } from '../err'
 
 
-class Nil extends ValBase {
+class NilVal extends Val {
   isNil = true
 
   nil = true
@@ -30,21 +27,23 @@ class Nil extends ValBase {
   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?: Context, why?: any, av?: Val, bv?: Val) => {
-    let nil = new Nil({ why }, 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.row = av.row
-      nil.col = av.col
-      nil.url = av.url
+      nil.site.row = av.site.row
+      nil.site.col = av.site.col
+      nil.site.url = av.site.url
 
       nil.primary = av
 
@@ -52,15 +51,15 @@ class Nil extends ValBase {
         nil.secondary = bv
 
         let bv_loc_wins =
-          (nil.url === bv.url) && (
-            (nil.row < bv.row) ||
-            (nil.row === bv.row && nil.col < bv.col)
+          (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.row = bv.row
-          nil.col = bv.col
-          nil.url = bv.url
+          nil.site.row = bv.site.row
+          nil.site.col = bv.site.col
+          nil.site.url = bv.site.url
           nil.primary = bv
           nil.secondary = av
         }
@@ -68,7 +67,7 @@ class Nil extends ValBase {
     }
 
     if (ctx) {
-      ctx.err.push(nil)
+      ctx.adderr(nil)
     }
 
     return nil
@@ -79,30 +78,33 @@ class Nil extends ValBase {
     spec?: {
       why?: string
       msg?: string
-      err?: Nil | Nil[] | Error | Error[]
+      err?: NilVal | NilVal[] | Error | Error[]
     } | string,
-    ctx?: Context
+    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] : [spec.err]) : []
+      this.err = spec ?
+        Array.isArray(spec.err) ? [...spec.err] :
+          null != spec.err ? [spec.err] :
+            [] : []
     }
 
     // Nil is always DONE, by definition.
-    this.done = DONE
+    this.dc = DONE
   }
 
 
-  unify(_peer: Val, _ctx: Context) {
+  unify(_peer: Val, _ctx: AontuContext) {
     return this
   }
 
 
-  clone(spec?: ValSpec, ctx?: Context): Val {
-    let out = (super.clone(spec, ctx) as Nil)
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as NilVal)
     out.why = this.why
 
     // Should these clone?
@@ -116,29 +118,39 @@ class Nil extends ValBase {
   }
 
 
+  // TODO: custom canon? useful for unknown function errors
   get canon() {
     return 'nil'
   }
 
-  gen(ctx?: Context) {
+
+  gen(ctx: AontuContext) {
     // Unresolved nil cannot be generated, so always an error.
 
-    descErr(this, ctx)
+    this.why = this.why ?? 'nil_gen'
+    ctx.adderr(this)
 
-    if (Array.isArray(ctx?.err)) {
-      ctx.err.push(this)
-    }
-    else {
-      const err: any = new Error(this.msg)
-      err.aontu = true
+    if (!ctx.collect) {
+      const err = new AontuError(this.msg, [this])
       throw err
     }
 
     return undefined
   }
+
+
+  superior(): Val {
+    return this
+  }
+
+
+  inspection() {
+    return this.why
+  }
+
 }
 
 
 export {
-  Nil,
+  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,
+}