theprogrammablemind 8.0.0-beta.41 → 8.0.0-beta.42

package/package.json

@@ -64,6 +64,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "8.0.0-beta.41",
+  "version": "8.0.0-beta.42",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -990,21 +990,6 @@ class Config {
 
   // value is in response field
   // TODO maybe generalize out query+evaluate along the lines of set value and set reference
-  /*
-  getEvaluator (s, log, context) {
-    const instance = s({ ...context, evaluate: true })
-    if (!instance.evalue && !instance.verbatim && !instance.value) {
-      this.warningNotEvaluated(log, context);
-    }
-    if (!instance.evalue) {
-      instance.evalue = instance.value
-      instance.edefault = true
-    }
-    delete instance.evaluate
-    instance.instance = true;
-    return instance
-  }
-  */
   async getEvaluator (s, calls, log, context) {
     const instance = await s({ ...context, evaluate: true })
     calls.touch(instance)

package/src/semantics.js

@@ -49,76 +49,50 @@ class Semantic {
     }
   }
 
-  async matches (baseArgs, context, options = {}) {
-    const hierarchy = baseArgs.hierarchy
-    const config = baseArgs.config
-
-    const objects = baseArgs.getObjects(this.uuid)
-    // const ask = baseArgs.getAsk(this.uuid)
-
-    // return this.matcher(Object.assign({}, argsBase, {args: contextArgs(context, hierarchy), objects: objects, global: objects, context: context, hierarchy: hierarchy, api: this.getAPI(config)})
-    const callId = baseArgs.calls.current()
-    const moreArgs = {
-      uuid: this.uuid,
-      args: contextArgs(context, hierarchy),
-      objects,
-      global: objects,
-      context: context,
-      // hierarchy: hierarchy,
-      callId,
-      api: this.getAPI(config),
-      apis: this.getAPIs(config)
+  fixUpArgs (args, context) {
+    args.uuid = this.uuid
+    args.callId = args.calls.current()
+    const objects = args.getObjects(this.uuid)
+    args.objects = objects
+    args.global = objects
+    const config = args.config
+    args.api = this.getAPI(config)
+    args.apis = this.getAPIs(config)
+    args.args = contextArgs(context, args.hierarchy)
+    args.context = context
+    let n = (id) => id
+    if (config && 'nsToString' in config) {
+      n = (id) => config.nsToString(id)
     }
-    const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
+    args.n = n
+    args.uuid = this.uuid
+    debugger
+    Object.assign(args, (args.getUUIDScoped || (() => { return {} }))(this.uuid))
+  }
 
+  async matches (args, context, options = {}) {
+    this.fixUpArgs(args, context)
     const matches = await this.matcher(args)
-    if (matches && (options.debug || {}).match ||
-        callId == this.callId) {
+    if (matches && (options.debug || {}).match || args.callId == this.callId) {
       debugger // next line is the matcher
       await this.matcher(args)
     }
     return matches
   }
 
-  async apply (baseArgs, context, s, log, options = {}) {
-    const { hierarchy, config, response } = baseArgs
-    const objects = baseArgs.getObjects(this.uuid)
+  async apply (args, context, s, options = {}) {
+    const { config } = args
     if (config && config.debugLoops) {
       console.log('apply', this.toLabel())
     }
-    if (baseArgs.calls && config && baseArgs.calls.stack.length > config.maxDepth) {
+    if (args.calls && config && args.calls.stack.length > config.maxDepth) {
       throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
     }
 
-    // const ask = baseArgs.getAsk(this.uuid)
-    if (!log) {
-      console.trace()
-      throw new Error('log is a required argument')
-    }
     const contextPrime = Object.assign({}, context)
-    let n = (id) => id
-    if (config && 'nsToString' in config) {
-      n = (id) => config.nsToString(id)
-    }
-    const callId = baseArgs.calls.current()
-    const moreArgs = {
-      uuid: this.uuid,
-      callId,
-      args: contextArgs(context, hierarchy),
-      objects,
-      log,
-      global: objects,
-      n,
-      context: contextPrime,
-      uuid: this.uuid,
-      // config,
-      response,
-      api: this.getAPI(config),
-      apis: this.getAPIs(config)
-    }
-    const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
-    if ((options.debug || {}).apply ||
-        callId == this.callId) {
+    this.fixUpArgs(args, contextPrime)
+
+    if ((options.debug || {}).apply || args.callId == this.callId) {
       debugger
     }
     if (args.breakOnSemantics) {
@@ -181,6 +155,7 @@ class Semantics {
     if (!(context instanceof Array || context instanceof Object)) {
       return context
     }
+    args = { ...args }
     const config = args.config
     let contextPrime = Object.assign({}, context)
     const s = (context, options) => this.apply(args, context, options)
@@ -188,6 +163,8 @@ class Semantics {
     const stack = args.calls.push()
     let counter = 0
     let seenQuestion = false
+    const deferred = []
+    args.log = (message) => { this.logs.push(message) }
     for (const isemantic in this.semantics) {
       const semantic = this.semantics[isemantic]
       if (!semantic) {
@@ -202,17 +179,28 @@ class Semantics {
           this.calls[counter] = 0
         }
         this.calls[counter] += 1
-        const log = (message) => { this.logs.push(message) }
         try {
-          contextPrime = await semantic.apply(args, context, s, log, options)
+          let deferWasCalled = false
+          const defer = (listener) => {
+            deferred.push({ semantic, listener })
+            deferWasCalled = true 
+          }
+          args.defer = defer
+          contextPrime = await semantic.apply(args, context, s, options)
+          if (deferWasCalled) {
+            continue
+          }
           if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
             // semantic.tied_ids.forEach((tied_id) => args.config.removeSemantic(tied_id))
             args.config.removeSemantic(semantic)
           }
+          for (const { listener } of deferred) {
+            listener(args)
+          }
         } catch (e) {
           contextPrime = null
           let errorMessage
-          e.retryCall = () => semantic.apply(args, context, s, log, options)
+          e.retryCall = () => semantic.apply(args, context, s, options)
           const help = 'The error has a retryCall property that will recall the function that failed.'
           if (e.stack && e.message) {
             const info = `${semantic.notes ? semantic.notes : ''}${semantic.where ? semantic.where : ''}`
@@ -280,6 +268,13 @@ class Semantics {
           lines.setElement(0, 1, 'RESULT')
           lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(contextPrime, { depth: 25 })))})`)
           lines.setElement(1, 2, JSON.stringify(contextPrime, null, 2))
+          for (const { semantic } of deferred) {
+            lines.setElement(0, 1, 'DEFERRED')
+            lines.setElement(0, 2, semantic.toLabel())
+            lines.newRow()
+            lines.setElement(0, 2, semantic.toString())
+            lines.newRow()
+          }
           this.logs.push(lines.toString())
         }
         applied = true