aontu 0.30.1 → 0.30.2

package/src/val/ScalarKindVal.ts

@@ -0,0 +1,125 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import {
+  explainOpen,
+  explainClose,
+} from '../utility'
+
+import { makeNilErr, AontuError } from '../err'
+
+// import { BaseVal } from './BaseVal'
+import { FeatureVal } from './FeatureVal'
+
+
+// A ScalarKind for integers. Number includes floats.
+class Integer { }
+
+// A ScalarKind for null.
+class Null { }
+
+
+type ScalarConstructor =
+  StringConstructor |
+  NumberConstructor |
+  BooleanConstructor |
+  (typeof Integer.constructor)
+
+
+// class ScalarKindVal extends BaseVal {
+class ScalarKindVal extends FeatureVal {
+  isScalarKind = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+
+    if (null == this.peg) {
+      throw new AontuError('ScalarKindVal spec.peg undefined')
+    }
+
+    this.dc = DONE
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'ScalarKind', this, peer)
+
+    const peerIsScalarVal = peer.isScalar
+    const peerIsScalarKind = (peer as ScalarKindVal).isScalarKind
+
+    let out: Val = this
+
+    if (peerIsScalarVal) {
+      let peerKind = (peer as any).kind
+
+      if (peerKind === this.peg) {
+        out = peer
+      }
+      else if (Number === this.peg && Integer === peerKind) {
+        out = peer
+      }
+      else {
+        out = makeNilErr(ctx, 'no-scalar-unify', this, peer)
+      }
+    }
+    else if (peerIsScalarKind) {
+      if (Number === this.peg && Integer === peer.peg) {
+        out = peer
+      }
+      else if (Number === peer.peg && Integer === this.peg) {
+        out = this
+      }
+      else if (this.peg === peer.peg) {
+        out = this
+      }
+      else {
+        out = makeNilErr(ctx, 'scalar-type', this, peer)
+      }
+    }
+    else {
+      out = makeNilErr(ctx, 'not-scalar-type', this, peer)
+    }
+
+    ctx.explain && explainClose(te, out)
+
+    // console.log('SCALARKINDVAL', this.canon.peer.canon, '->', out.canon)
+    return out
+  }
+
+
+  get canon() {
+    let ctor = (this.peg as any)
+    return ctor.name.toLowerCase()
+  }
+
+
+  same(peer: any): boolean {
+    let out = peer?.isScalarKind ? this.peg === peer?.peg : super.same(peer)
+    return out
+  }
+
+
+}
+
+
+export {
+  Integer,
+  Null,
+  ScalarConstructor,
+  ScalarKindVal,
+}

package/src/val/ScalarVal.ts

@@ -0,0 +1,105 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import type {
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import {
+  explainOpen,
+  explainClose,
+} from '../utility'
+
+import { makeNilErr } from '../err'
+
+import { Val } from './Val'
+import { ScalarKindVal } from './ScalarKindVal'
+
+
+
+class ScalarVal extends Val {
+  kind: any
+  isScalar = true
+  src: string
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.kind = spec.kind
+    this.src = spec.src ?? ''
+    this.dc = DONE
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = super.clone(ctx, {
+      peg: this.peg,
+      kind: this.kind,
+      ...(spec || {})
+    })
+
+    return out
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Scalar', this, peer)
+
+    let out: Val
+
+    // Exactly equal scalars are handled in unify.unite
+    if (peer.isScalarKind) {
+      out = peer.unify(this, ctx)
+    }
+    else if (peer.isTop) {
+      out = this
+    }
+    else {
+      out = makeNilErr(ctx, 'scalar_' +
+        ((peer as any).kind === this.kind ? 'value' : 'kind'), this, peer)
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  get canon() {
+    return null === this.peg ? 'null' :
+      undefined === this.peg ? 'undefined' :
+        (this.peg as any).toString()
+  }
+
+
+  same(peer: any): boolean {
+    return peer?.isScalar ? peer.peg === this.peg : super.same(peer)
+  }
+
+
+  gen(_ctx?: AontuContext) {
+    return this.peg
+  }
+
+
+  superior() {
+    return this.place(new ScalarKindVal({
+      peg: this.kind
+    }))
+  }
+
+}
+
+
+export {
+  ScalarVal,
+}

package/src/val/StringVal.ts

@@ -0,0 +1,37 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { ScalarVal } from './ScalarVal'
+
+
+class StringVal extends ScalarVal {
+  isString = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super({ peg: spec.peg, kind: String }, ctx)
+  }
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    return super.unify(peer, ctx)
+  }
+
+  get canon() {
+    return JSON.stringify(this.peg)
+  }
+
+}
+
+export {
+  StringVal,
+}

package/src/val/SuperFuncVal.ts

@@ -0,0 +1,46 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class SuperFuncVal extends FuncBaseVal {
+  isSuperFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new SuperFuncVal(spec)
+  }
+
+  funcname() {
+    return 'super'
+  }
+
+
+  resolve(_ctx: AontuContext, _args: Val[]) {
+    return this.place(this.superior())
+  }
+
+}
+
+
+export {
+  SuperFuncVal,
+}

package/src/val/TopVal.ts

@@ -0,0 +1,69 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import { inspect } from 'node:util'
+
+import type {
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import {
+  Val
+} from './Val'
+
+
+// There can be only one.
+class TopVal extends Val {
+  isTop = true
+
+  id = 0
+  dc = DONE
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+
+    // TOP is always DONE, by definition.
+    this.dc = DONE
+    this.mark.type = false
+    this.mark.hide = false
+  }
+
+  same(peer: Val): boolean {
+    // return this === peer
+    return peer.isTop
+  }
+
+  unify(peer: Val, _ctx?: AontuContext): Val {
+    return peer
+  }
+
+  get canon() { return 'top' }
+
+  superior(): Val {
+    return this
+  }
+
+  clone(_ctx: AontuContext, _spec?: ValSpec) {
+    return this
+  }
+
+  gen(_ctx?: AontuContext) {
+    return undefined
+  }
+
+}
+
+
+export {
+  TopVal,
+}

package/src/val/TypeFuncVal.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 {
+  walk,
+  explainOpen,
+  explainClose,
+} from '../utility'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class TypeFuncVal extends FuncBaseVal {
+  isTypeFunc = 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 TypeFuncVal(spec)
+  }
+
+  funcname() {
+    return 'type'
+  }
+
+
+  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.type = true
+        return val
+      })
+    }
+
+    return out
+  }
+}
+
+
+export {
+  TypeFuncVal,
+}

package/src/val/UpperFuncVal.ts

@@ -0,0 +1,72 @@
+/* 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 { ScalarKindVal } from '../val/ScalarKindVal'
+import { makeScalar } from '../val/valutil'
+
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+
+
+class UpperFuncVal extends FuncBaseVal {
+  isUpperFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new UpperFuncVal(spec)
+  }
+
+  funcname() {
+    return 'upper'
+  }
+
+
+  resolve(ctx: AontuContext | undefined, args: Val[]) {
+    const oldpeg = args?.[0].peg
+    const peg = 'string' === typeof oldpeg ? oldpeg.toUpperCase() :
+      'number' === typeof oldpeg ? Math.ceil(oldpeg) :
+        undefined
+    const out = this.place(
+      null == peg ?
+        makeNilErr(ctx, 'invalid-arg', this) :
+        makeScalar(peg)
+    )
+    return out
+  }
+
+
+  superior() {
+    const arg = this.peg?.[0]
+    return arg?.isScalar ?
+      this.place(new ScalarKindVal({
+        peg: arg.kind
+      })) :
+      super.superior()
+  }
+}
+
+
+export {
+  UpperFuncVal,
+}