aontu 0.29.0 → 0.30.2

package/lib/val/OpVal.ts

@@ -1,159 +0,0 @@
-/* Copyright (c) 2024 Richard Rodger, MIT License */
-
-
-import type {
-  Val,
-  ValSpec,
-} from '../type'
-
-import {
-  DONE,
-} from '../type'
-
-import {
-  descErr
-} from '../err'
-
-import {
-  Context,
-} from '../unify'
-
-import {
-  unite
-} from '../op/op'
-
-import {
-  TOP,
-  StringVal,
-} from '../val'
-
-
-import { ConjunctVal } from '../val/ConjunctVal'
-import { MapVal } from '../val/MapVal'
-import { Nil } from '../val/Nil'
-import { VarVal } from '../val/VarVal'
-import { ValBase } from '../val/ValBase'
-
-
-
-
-
-class OpVal extends ValBase {
-  isOpVal = true
-
-  constructor(
-    spec: {
-      peg: any[],
-    },
-    ctx?: Context
-  ) {
-    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)
-  }
-
-
-  unify(peer: Val, ctx: Context): Val {
-    let out: Val = this
-
-    if (this.id !== peer.id) {
-      let result: Val | undefined = null == ctx ? this : this.operate(ctx)
-
-      result = result || this
-
-      if (null == result && this.canon === peer.canon) {
-        out = this
-      }
-      else if (result instanceof OpVal) {
-        if (TOP === peer) {
-          out = this
-        }
-        else if (peer instanceof Nil) {
-          out = Nil.make(ctx, 'op[' + this.peg + ']', this, peer)
-        }
-
-        else if (this.canon === peer.canon) {
-          out = this
-        }
-
-        else {
-          this.done = DONE === this.done ? DONE : this.done + 1
-          out = new ConjunctVal({ peg: [this, peer] }, ctx)
-        }
-      }
-      else {
-        out = unite(ctx, result, peer, 'op')
-      }
-
-      out.done = DONE === out.done ? DONE : this.done + 1
-    }
-
-    return out
-  }
-
-
-  same(peer: Val): boolean {
-    return null == peer ? false : this.peg === peer.peg
-  }
-
-
-  clone(_spec?: ValSpec, ctx?: Context): Val {
-    let out = (super.clone({
-      peg: this.peg,
-    }, ctx) as OpVal)
-    return out
-  }
-
-
-  operate(ctx: Context): Val | undefined {
-    this.peg = this.peg.map((v: any) => v.isRefVal ? v.unify(TOP, ctx) : v)
-    return undefined
-  }
-
-
-
-  get canon() {
-    return ''
-  }
-
-
-  gen(ctx?: Context) {
-    // Unresolved op cannot be generated, so always an error.
-    let nil = Nil.make(
-      ctx,
-      'op',
-      this,
-      undefined
-    )
-
-    // TODO: refactor to use Site
-    nil.path = this.path
-    nil.url = this.url
-    nil.row = this.row
-    nil.col = this.col
-
-    descErr(nil, ctx)
-
-    if (ctx) {
-      ctx.err.push(nil)
-    }
-    else {
-      throw new Error(nil.msg)
-    }
-
-    return undefined
-  }
-}
-
-
-export {
-  OpVal,
-}

package/lib/val/PlusVal.ts

@@ -1,76 +0,0 @@
-/* Copyright (c) 2024 Richard Rodger, MIT License */
-
-
-import type {
-  Val,
-  ValSpec,
-} from '../type'
-
-import {
-  DONE,
-} from '../type'
-
-import {
-  descErr
-} from '../err'
-
-import {
-  Context,
-} from '../unify'
-
-import {
-  unite
-} from '../op/op'
-
-
-import { TOP, IntegerVal, NumberVal, StringVal } from '../val'
-import { Nil } from '../val/Nil'
-import { OpVal } from '../val/OpVal'
-
-
-
-
-
-class PlusVal extends OpVal {
-  isOpVal = true
-
-  constructor(
-    spec: {
-      peg: any[],
-    },
-    ctx?: Context
-  ) {
-    super(spec, ctx)
-  }
-
-
-  operate(ctx: Context) {
-    super.operate(ctx)
-
-    if (this.peg.find((v: any) => v.isRefVal)) {
-      return undefined
-    }
-
-    let peg = this.peg[0].peg + this.peg[1].peg
-    let pegtype = typeof peg
-    if ('string' === pegtype) {
-      return new StringVal({ peg })
-    }
-    else if ('number' === pegtype) {
-      return Number.isInteger(peg) ? new IntegerVal({ peg }) : new NumberVal({ peg })
-    }
-
-    return undefined
-  }
-
-
-  get canon() {
-    return this.peg[0].canon + '+' + this.peg[1].canon
-  }
-
-}
-
-
-export {
-  PlusVal,
-}

package/lib/val/PrefVal.ts

@@ -1,154 +0,0 @@
-/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
-
-
-
-import type {
-  Val,
-  ValSpec,
-} from '../type'
-
-import {
-  DONE,
-} from '../type'
-
-import {
-  descErr
-} from '../err'
-
-import {
-  Context,
-} from '../unify'
-
-
-import {
-  Site
-} from '../lang'
-
-
-import {
-  unite
-} from '../op/op'
-
-
-
-// import { TOP } from '../val'
-// import { ConjunctVal } from '../val/ConjunctVal'
-// import { DisjunctVal } from '../val/DisjunctVal'
-// import { ListVal } from '../val/ListVal'
-// import { MapVal } from '../val/MapVal'
-import { Nil } from '../val/Nil'
-// import { RefVal } from '../val/RefVal'
-import { ValBase } from '../val/ValBase'
-
-
-class PrefVal extends ValBase {
-  isPrefVal = true
-
-  pref: Val
-
-  constructor(
-    spec: {
-      peg: any,
-      pref?: any
-    },
-    ctx?: Context
-  ) {
-    super(spec, ctx)
-    this.pref = spec.pref || spec.peg
-  }
-
-  // PrefVal unify always returns a PrefVal
-  // PrefVals can only be removed by becoming Nil in a Disjunct
-  unify(peer: Val, ctx: Context): Val {
-    let done = true
-    let out: Val
-
-    if (peer instanceof PrefVal) {
-      out = new PrefVal(
-        {
-          peg: unite(ctx, this.peg, peer.peg, 'Pref000'),
-          pref: unite(ctx, this.pref, peer.pref, 'Pref010'),
-        },
-        ctx
-      )
-    }
-
-    else {
-      out = new PrefVal(
-        {
-          // TODO: find a better way to drop Nil non-errors
-          peg: unite(ctx?.clone({ err: [] }), this.peg, peer, 'Pref020'),
-          pref: unite(ctx?.clone({ err: [] }), this.pref, peer, 'Pref030'),
-        },
-        ctx
-      )
-    }
-
-    done = done && DONE === out.peg.done &&
-      (null != (out as PrefVal).pref ? DONE === (out as PrefVal).pref.done : true)
-
-    if (out.peg instanceof Nil) {
-      out = (out as PrefVal).pref
-    }
-    else if ((out as PrefVal).pref instanceof Nil) {
-      out = out.peg
-    }
-
-    out.done = done ? DONE : this.done + 1
-
-    return out
-  }
-
-
-  same(peer: Val): boolean {
-    if (null == peer) {
-      return false
-    }
-
-    let pegsame = (this.peg === peer.peg) ||
-      (this.peg instanceof ValBase && this.peg.same(peer.peg))
-
-    let prefsame = peer instanceof PrefVal &&
-      ((this.pref === peer.pref) ||
-        (this.pref instanceof ValBase && this.pref.same(peer.pref)))
-
-    return pegsame && prefsame
-  }
-
-
-  clone(spec?: ValSpec, ctx?: Context): Val {
-    let out = (super.clone(spec, ctx) as PrefVal)
-    out.pref = this.pref.clone(null, ctx)
-    return out
-  }
-
-
-  get canon() {
-    return this.pref instanceof Nil ? this.peg.canon : '*' + this.pref.canon
-  }
-
-  gen(ctx?: Context) {
-    let val = !(this.pref instanceof Nil) ? this.pref :
-      (!(this.peg instanceof Nil) ? this.peg :
-        this.pref)
-
-    if (val instanceof Nil) {
-      descErr(val, ctx)
-
-      if (ctx) {
-        ctx.err.push(val)
-      }
-      else {
-        throw new Error(val.msg)
-      }
-    }
-
-    return val.gen(ctx)
-  }
-}
-
-
-
-export {
-  PrefVal,
-}