aontu 0.3.0 → 0.6.1

package/lib/val/RefVal.ts~

@@ -0,0 +1,319 @@
+/* Copyright (c) 2021 Richard Rodger, MIT License */
+
+// TODO: infinite recursion protection
+
+
+// NOTES
+// - Vals are immutable
+// - each Val must handle all parent and child unifications explicitly
+// - performance is not considered yet
+
+
+
+/*
+
+TOP -> Scalar/Boolean -> BooleanVal
+    -> Scalar/String  -> StringVal
+    -> Scalar/Number  -> NumberVal -> IntegerVal
+         -> Scalar/Integer 
+    -> Scalar/Integer -> IntegerVal
+
+*/
+
+
+import type {
+  Val,
+  ValMap,
+  ValList,
+} from './type'
+
+import {
+  DONE,
+  TOP,
+} from './type'
+
+import {
+  Context,
+} from './unify'
+
+
+import {
+  Site
+} from './lang'
+
+
+import {
+  unite
+} from './op/op'
+
+import { Nil } from './val/Nil'
+
+import {
+  ValBase,
+} from './val/ValBase'
+
+import { ConjunctVal } from './val/ConjunctVal'
+
+
+
+
+
+
+// A ScalarType for integers. Number includes floats.
+class Integer { }
+
+
+
+type ScalarConstructor =
+  StringConstructor |
+  NumberConstructor |
+  BooleanConstructor |
+  (typeof Integer.constructor)
+
+
+class ScalarTypeVal extends ValBase {
+  constructor(peg: ScalarConstructor, ctx?: Context) {
+    super(peg, ctx)
+    this.done = DONE
+  }
+
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarVal) {
+      if (peer.type === this.peg) {
+        return peer
+      }
+      else if (Number === this.peg && Integer === peer.type) {
+        return peer
+      }
+      return Nil.make(ctx, 'no-scalar-unify', this, peer)
+    }
+    else {
+      if (peer instanceof ScalarTypeVal) {
+        if (Number === this.peg && Integer === peer.peg) {
+          return peer
+        }
+        else if (Number === peer.peg && Integer === this.peg) {
+          return this
+        }
+      }
+      return Nil.make(ctx, 'scalar-type', this, peer)
+    }
+  }
+
+  get canon() {
+    let ctor = (this.peg as any)
+    return ctor.name.toLowerCase()
+  }
+
+  same(peer: Val): boolean {
+    return peer instanceof ScalarTypeVal ? this.peg === peer.peg : super.same(peer)
+  }
+
+  gen(_ctx?: Context) {
+    return undefined
+  }
+
+}
+
+
+class ScalarVal<T> extends ValBase {
+  type: any
+  constructor(peg: T, type: ScalarConstructor, ctx?: Context) {
+    super(peg, ctx)
+    this.type = type
+    this.done = DONE
+  }
+  unify(peer: Val, ctx: Context): Val {
+    // Exactly equal scalars are handled in op/unite
+    if (peer instanceof ScalarTypeVal) {
+      return peer.unify(this, ctx)
+    }
+    return Nil.make(ctx, 'scalar', this, peer)
+  }
+  get canon() {
+    return (this.peg as any).toString()
+  }
+  same(peer: Val): boolean {
+    return peer instanceof ScalarVal ? peer.peg === this.peg : super.same(peer)
+  }
+
+  gen(_ctx?: Context) {
+    return this.peg
+  }
+}
+
+
+class NumberVal extends ScalarVal<number> {
+  constructor(peg: number, ctx?: Context) {
+    super(peg, Number, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarVal && peer.type === Integer) {
+      return peer
+    }
+    else {
+      return super.unify(peer, ctx)
+    }
+  }
+}
+
+
+class IntegerVal extends ScalarVal<number> {
+  constructor(peg: number, ctx?: Context) {
+    if (!Number.isInteger(peg)) {
+      // TODO: use Nil?
+      throw new Error('not-integer')
+    }
+    super(peg, Integer, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    if (peer instanceof ScalarTypeVal && peer.peg === Number) {
+      return this
+    }
+    else if (peer instanceof ScalarVal &&
+      peer.type === Number &&
+      this.peg === peer.peg) {
+      return this
+    }
+    else {
+      return super.unify(peer, ctx)
+    }
+  }
+}
+
+
+class StringVal extends ScalarVal<string> {
+  constructor(peg: string, ctx?: Context) {
+    super(peg, String, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    return super.unify(peer, ctx)
+  }
+  get canon() {
+    return JSON.stringify(this.peg)
+  }
+
+}
+
+
+class BooleanVal extends ScalarVal<boolean> {
+  constructor(peg: boolean, ctx?: Context) {
+    super(peg, Boolean, ctx)
+  }
+  unify(peer: Val, ctx: Context): Val {
+    return super.unify(peer, ctx)
+  }
+
+  static TRUE = new BooleanVal(true, new Context({ vc: 1, root: TOP }))
+  static FALSE = new BooleanVal(false, new Context({ vc: 2, root: TOP }))
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class RefVal extends ValBase {
+  parts: string[]
+  absolute: boolean
+  sep = '.'
+
+  constructor(peg: any[], abs?: boolean) {
+    super('')
+    this.absolute = true === abs
+    this.parts = []
+
+    for (let part of peg) {
+      this.append(part)
+    }
+  }
+
+
+  append(part: any) {
+    //console.log('APPEND 0', part)
+
+    if ('string' === typeof part) {
+      this.parts.push(part)
+    }
+
+    else if (part instanceof StringVal) {
+      this.parts.push(part.peg)
+    }
+
+    else if (part instanceof RefVal) {
+      this.parts.push(...part.parts)
+
+      if (part.absolute) {
+        this.absolute = true
+      }
+    }
+
+    this.peg = (this.absolute ? this.sep : '') + this.parts.join(this.sep)
+  }
+
+  unify(peer: Val, ctx: Context): Val {
+    let resolved: Val | undefined = null == ctx ? this : ctx.find(this)
+
+    // TODO: large amount of reruns needed? why?
+    resolved = null == resolved && 999 < this.done ?
+      Nil.make(ctx, 'no-path', this, peer) : (resolved || this)
+    let out: Val
+
+    if (resolved instanceof RefVal) {
+      if (TOP === peer) {
+        out = this
+      }
+      else if (peer instanceof Nil) {
+        out = Nil.make(ctx, 'ref[' + this.peg + ']', this, peer)
+      }
+      else {
+        // Ensure RefVal done is incremented
+        this.done = DONE === this.done ? DONE : this.done + 1
+        out = new ConjunctVal([this, peer], ctx)
+      }
+    }
+    else {
+      out = unite(ctx, resolved, peer)
+    }
+
+    out.done = DONE === out.done ? DONE : this.done + 1
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : this.peg === peer.peg
+  }
+
+
+  get canon() {
+    return this.peg
+  }
+
+
+  gen(_ctx?: Context) {
+    return undefined
+  }
+}
+
+
+export {
+  Integer,
+  TOP,
+  ScalarTypeVal,
+  NumberVal,
+  StringVal,
+  BooleanVal,
+  IntegerVal,
+  RefVal,
+}

package/lib/val/ValBase.ts

@@ -0,0 +1,76 @@
+/* Copyright (c) 2021-2022 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+} from '../type'
+
+import {
+  DONE,
+  TOP,
+} from '../type'
+
+import {
+  Context,
+} from '../unify'
+
+
+import {
+  Site
+} from '../lang'
+
+
+import {
+  unite
+} from '../op/op'
+
+
+
+
+
+abstract class ValBase implements Val {
+  id: number
+  done: number = 0
+  path: string[]
+  row: number = -1
+  col: number = -1
+  url: string = ''
+
+  top?: boolean
+
+  // Actual native value.
+  peg?: any
+
+  // TODO: used for top level result - not great
+  err?: any[]
+  deps?: any
+
+  constructor(peg?: any, ctx?: Context) {
+    this.peg = peg
+    this.path = (ctx && ctx.path) || []
+    this.id = (ctx && ctx.vc++) || (9e9 + Math.floor(Math.random() * (1e9)))
+  }
+
+  same(peer: Val): boolean {
+    // return this === peer
+    return null == peer ? false : this.id === peer.id
+  }
+
+  get site(): Site {
+    return new Site(this)
+  }
+
+
+  // TODO: can ctx be optional?
+  abstract unify(peer: Val, ctx?: Context): Val
+  abstract get canon(): string
+  abstract gen(ctx?: Context): any
+}
+
+
+
+
+export {
+  ValBase,
+}