theprogrammablemind 8.0.0-beta.8 → 8.0.0-beta.80

package/src/semantics.js

@@ -49,82 +49,55 @@ class Semantic {
     }
   }
 
-  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
+    Object.assign(args, (args.getUUIDScoped || (() => { return {} }))(this.uuid))
+  }
 
-    const matches = this.matcher(args)
-    if (matches && (options.debug || {}).match ||
-        callId == this.callId) {
+  async matches (args, context, options = {}) {
+    this.fixUpArgs(args, context)
+    const matches = await this.matcher(args)
+    if (matches && (options.debug || {}).match || args.callId == this.callId) {
       debugger // next line is the matcher
-      this.matcher(args)
+      await this.matcher(args)
     }
     return matches
   }
 
-  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) {
       debugger
     }
-    this._apply(args)
+    await this._apply(args)
     return contextPrime
   }
 }
@@ -176,11 +149,12 @@ class Semantics {
     return this.semantics[maxOrdinal]
   }
 
-  applyToContext (args, context, options) {
+  async applyToContext (args, context, options) {
     // let context_prime = {}
     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 +162,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) {
@@ -197,22 +173,33 @@ class Semantics {
       if (semantic.isQuestion && seenQuestion) {
         continue
       }
-      if (semantic.matches(args, context, options)) {
+      if (await semantic.matches(args, context, options)) {
         if (!this.calls[counter]) {
           this.calls[counter] = 0
         }
         this.calls[counter] += 1
-        const log = (message) => { this.logs.push(message) }
         try {
-          contextPrime = 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 +267,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
@@ -310,19 +304,19 @@ class Semantics {
     return contextPrime
   }
 
-  applyToContexts (args, contexts, options) {
+  async applyToContexts (args, contexts, options) {
     const contextsPrime = []
-    contexts.forEach((context) => {
-      contextsPrime.push(this.applyToContext(args, context, options))
-    })
+    for (const context of contexts) {
+      contextsPrime.push(await this.applyToContext(args, context, options))
+    }
     return contextsPrime
   }
 
-  apply (args, context, options) {
+  async apply (args, context, options) {
     if (Array.isArray(context)) {
-      return this.applyToContexts(args, context, options)
+      return await this.applyToContexts(args, context, options)
     } else if (context instanceof Object) {
-      return this.applyToContext(args, context, options)
+      return await this.applyToContext(args, context, options)
     } else {
       return context
     }