theprogrammablemind 7.5.8-beta.8 → 7.5.8-beta.80

package/src/flatten.js

@@ -89,7 +89,15 @@ const flatten = (markers, value) => {
   const split = markers.includes(marker)
   if (split) {
     if ('value' in properties) {
-      return [properties.value, true]
+      flattenedValues = []
+      for (let v of properties.value) {
+        if (v.flatten) {
+          flattenedValues = flattenedValues.concat(flatten(markers, v)[0])
+        } else {
+          flattenedValues.push(v)
+        }
+      }
+      return [flattenedValues, true]
     } else {
       return [[value], false]
     }

package/src/helpers.js

@@ -43,6 +43,16 @@ const appendNoDups = (l1, l2) => {
   }
 }
 
+const safeNoDups = (list) => {
+  noDups = []
+  for (const element of list) {
+    if (!noDups.find((e) => safeEquals(e, element))) {
+      noDups.push(element)
+    }
+  }
+  return noDups
+}
+
 const safeEquals = (v1, v2) => {
   if (typeof v1 !== typeof v2) {
     return false
@@ -53,6 +63,8 @@ const safeEquals = (v1, v2) => {
     return v1 == v2
   } else if (type == 'function') {
     return v1.toString() == v2.toString()
+  } else if (v1 == undefined || v2 == undefined) {
+    return v1 == v2
   } else {
     if (v1.length != v2.length) {
       return false
@@ -170,9 +182,6 @@ const isCompound = (value) => {
   return isArray(value) || isObject(value)
 }
 
-nextCallId = 0
-nextContextId = 0
-
 class InitCalls {
 
   constructor(name) {
@@ -196,9 +205,10 @@ class InitCalls {
     // this.nextCallId += 1
     // this.stack.push(this.nextCallId)
     this.stack.push(this.nextCallId)
+    // TODO put the nextContextId in the context for debugging
     const calls = this.stack.map( (call) => `${this.name}#call${call}` )
     // return `Context#${this.nextContextId}: ${calls}`
-    return `Context#${nextContextId}: ${calls}`
+    return `Context#${this.nextContextId}: ${calls}`
   }
 
   current() {
@@ -320,7 +330,7 @@ const ecatch = (where, call) => {
   try {
     return call()
   } catch( e ) {
-    throw new Error(`${where} ${e}`)
+    throw new Error(`${where} ${e.stack}`)
   }
 }
 
@@ -331,6 +341,7 @@ module.exports = {
   mapInPlace,
   validProps, 
   args, 
+  safeNoDups,
   safeEquals, 
   appendNoDups, 
   hashIndexesGet, 

package/src/project.js

@@ -0,0 +1,81 @@
+
+const project = (object, filter) => {
+  if (!object) {
+    return
+  }
+
+  let projection = {}
+  const set = (property, value) => {
+    if (value === null || value === undefined) {
+      return
+    }
+    projection[property] = value
+  }
+  if (Array.isArray(filter)) {
+    if (Array.isArray(object)) {
+      return object.map( element => project(element, filter) )
+    } else {
+      for (let properties of filter) {
+        if (typeof properties == 'object') {
+          if (properties.propertyLists) {
+            for (const propertyList in properties.propertyLists) {
+              if (object[propertyList]) {
+                for (const property of object[propertyList]) {
+                  set(property, project(object[property], properties.propertyLists[propertyList]))
+                }
+              }
+            }
+          } 
+          if (properties.valueLists) {
+            for (const listProperty in properties.valueLists) {
+              const old = object[listProperty]
+              if (Array.isArray(old)) {
+                set(listProperty, old.map((element) => project(element, properties.valueLists[listProperty])))
+              } else {
+                set(listProperty, project(old, properties.valueLists[listProperty]))
+              }
+            }
+          }
+          if (properties.properties) {
+            for (const property in properties.properties) {
+              const old = object[property]
+              set(property, project(old, properties.properties[property]))
+            }
+          }
+          if (properties.property) {
+            const property = properties.property
+            if (properties.isPropertyList) {
+              debugger
+              if (!Array.isArray(object[property])) {
+                return projection
+              }
+              for (const propertyRef of object[property]) {
+                const old = object[propertyRef]
+                set(propertyRef, project(old, properties.filter))
+              }
+            } else {
+              const old = object[property]
+              set(property, project(old, properties.filter))
+            }
+          }
+        } else {
+          if (!Array.isArray(properties)) {
+            properties = [properties]
+          }
+          for (const property of properties) {
+            set(property, object[property])
+          }
+        }
+      }
+    }
+  } else if (typeof filter == 'object') {
+    for (const property of Object.keys(filter)) {
+      set(property, project(object[property], filter[property]))
+    }
+  }
+  return projection
+}
+
+module.exports = { project }
+
+

package/src/semantics.js

@@ -6,7 +6,7 @@ class Semantic {
   // constructor ({match, apply, uuid, index, km, notes}) {
   constructor (semantic) {
     semantic = normalizeSemantic(semantic)
-    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property } = semantic
+    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property, oneShot, id } = semantic
     this.matcher = match
     this._apply = apply
     this._applyWrapped = applyWrapped
@@ -18,6 +18,8 @@ class Semantic {
     this.notes = notes
     this.callId = debug
     this.where = where
+    this.oneShot = oneShot
+    this.id = id
   }
 
   toLabel () {
@@ -197,6 +199,9 @@ class Semantics {
         const log = (message) => { this.logs.push(message) }
         try {
           contextPrime = semantic.apply(args, context, s, log, options)
+          if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
+            args.config.removeSemantic(semantic)
+          }
         } catch( e ) {
           contextPrime = null
           let errorMessage