tpmkms_4wp 9.4.5-beta.4 → 9.4.5-beta.6

package/common/fastfood.js

@@ -103,6 +103,7 @@ const template = {
     "go modifies wrap",
     "a go wrap is a sandwich",
     "chicken modifies go wrap",
+    // { stop: true },
     "breakfast baconator, french toast sandwich, egg muffin, chicken on french toast, pancake platter, double sausage muffin, pancakes, french toast and oatmeal are breakfast meals",
     "single, double, triple, baconator, bacon deluxe, spicy homestyle and premium cod are meals",
     "coca modifies cola",

package/common/gdefaults.js

@@ -248,16 +248,41 @@ const initializer = ({config}) => {
               return args.gp(context[key])
             }
           }
+          const getValue = (keyOrValue) => {
+            if (typeof keyOrValue == 'string' && context[keyOrValue]) {
+              return context[keyOrValue]
+            }
+            return keyOrValue // it's a value
+          }
+
           if (Array.isArray(interpolate)) {
             const strings = []
             let separator = ''
             for (const element of interpolate) {
               if (typeof element == 'string') {
                 separator = element
+              } else if (element.separator && element.values) {
+                let ctr = 0
+                const values = getValue(element.values)
+                const vstrings = []
+                for (const value of values) {
+                  if (ctr == values.length-1) {
+                    vstrings.push(getValue(element.separator))
+                  }
+                  ctr += 1
+                  vstrings.push(getValue(value))
+                }
+                strings.push(await args.gsp(vstrings))
               } else {
-                strings.push(separator)
-                strings.push(await args.gp(element))
-                separator = ' '
+                let value = element
+                if (element.property) {
+                  value = context[element.property]
+                }
+                if (value) {
+                  strings.push(separator)
+                  strings.push(await args.gp(value))
+                  separator = ' '
+                }
               }
             }
             return strings.join('')

package/common/latin.instance.json

@@ -1,15 +1,162 @@
 {
   "configs": [
+    {
+      "apply": "({config}) => {\n      config.addArgs(({config, api, isA}) => ({\n        addLatinNoun: ({ id, nominative, genetive, development }) => {\n          config.addOperator({ pattern: `([${id}|])`, development: development })\n          config.addBridge({ id, isA: ['hierarchiable'] })\n          const declensions = getDeclensions(nominative, genetive)\n          for (const declension of declensions) {\n            config.addWord(declension.word, { id, initial: { ...declension, development } })\n          }\n        }\n      }))\n    }"
+    },
+    {
+      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })\n    }"
+    },
     {
       "operators": [
         "((hierarchy/*) [queryMarker|ne])",
-        "((listable/*) [listMarker|que])",
         "([hierarchiable])",
         "((hierarchiable) [hierarchy|] (hierarchiable))",
         "((hierarchiable) (hierarchiable) [hierarchy|])",
-        "([hierarchy|] (hierarchiable) (hierarchiable))"
+        "([hierarchy|] (hierarchiable) (hierarchiable))",
+        "(x [list|et] y)",
+        "((listable/*) [listMarker|que])"
       ],
       "bridges": [
+        {
+          "id": "inLatin",
+          "words": [
+            "in"
+          ],
+          "before": [
+            "iacere"
+          ],
+          "bridge": "{ ...next(operator), declension: 'inLatin', object: object, operator: operator, interpolate: [{ property: 'operator' }, { property: 'object' }] }",
+          "selector": {
+            "ordinals": [
+              1
+            ],
+            "arguments": {
+              "object": "(context.declension == 'accusative' || context.declension == 'ablative')"
+            }
+          }
+        },
+        {
+          "id": "iacere",
+          "level": 0,
+          "words": [
+            {
+              "word": "iacio",
+              "number": "singular",
+              "person": "first"
+            },
+            {
+              "word": "iacis",
+              "number": "singular",
+              "person": "second"
+            },
+            {
+              "word": "iacit",
+              "number": "singular",
+              "person": "third"
+            },
+            {
+              "word": "iacimus",
+              "number": "plural",
+              "person": "first"
+            },
+            {
+              "word": "iacitis",
+              "number": "plural",
+              "person": "second"
+            },
+            {
+              "word": "iaciunt",
+              "number": "plural",
+              "person": "third"
+            }
+          ],
+          "bridge": "{ ...next(operator), thrower: nominative?, receiver: dative?, object: object?, location: location?, interpolate: [{ property: 'thrower' }, { property: 'receiver' }, { property: 'location' }, { property: 'object' }, operator] }",
+          "selector": {
+            "arguments": {
+              "nominative": "(context.declension == 'nominative' && context.number == operator.number)",
+              "dative": "(context.declension == 'dative')",
+              "object": "(context.declension == 'accusative')",
+              "location": "(context.declension == 'inLatin')"
+            }
+          }
+        },
+        {
+          "id": "dare",
+          "level": 0,
+          "bridge": "{ ...next(operator), giver: nominative?, receiver: dative?, object: accusative?, interpolate: [{ property: 'giver' }, { property: 'receiver' }, { property: 'object' }, operator] }",
+          "selector": {
+            "arguments": {
+              "nominative": "(context.declension == 'nominative' && context.number == operator.number)",
+              "dative": "(context.declension == 'dative')",
+              "accusative": "(context.declension == 'accusative')"
+            }
+          },
+          "words": [
+            {
+              "word": "do",
+              "number": "singular",
+              "person": "first"
+            },
+            {
+              "word": "das",
+              "number": "singular",
+              "person": "second"
+            },
+            {
+              "word": "dat",
+              "number": "singular",
+              "person": "third"
+            },
+            {
+              "word": "damus",
+              "number": "plural",
+              "person": "first"
+            },
+            {
+              "word": "datis",
+              "number": "plural",
+              "person": "second"
+            },
+            {
+              "word": "dant",
+              "number": "plural",
+              "person": "third"
+            }
+          ]
+        },
+        {
+          "id": "list",
+          "level": 0,
+          "selector": {
+            "match": "same",
+            "left": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "right": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "passthrough": true
+          },
+          "bridge": "{ ...next(operator), listable: true, isList: true, value: append(before, after), operator: operator, interpolate: [ { separator: 'operator', values: 'value' } ] }"
+        },
+        {
+          "id": "list",
+          "level": 1,
+          "selector": {
+            "match": "same",
+            "left": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "passthrough": true
+          },
+          "bridge": "{ ...operator, value: append(before, operator.value) }"
+        },
         {
           "id": "queryMarker",
           "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], question: true }",
@@ -26,7 +173,7 @@
               "listable"
             ]
           ],
-          "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], list: true }",
+          "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], isList: true }",
           "separators": "|"
         },
         {
@@ -87,17 +234,164 @@
     }
   ],
   "resultss": [
+    {
+      "apply": "({config}) => {\n      config.addArgs(({config, api, isA}) => ({\n        addLatinNoun: ({ id, nominative, genetive, development }) => {\n          config.addOperator({ pattern: `([${id}|])`, development: development })\n          config.addBridge({ id, isA: ['hierarchiable'] })\n          const declensions = getDeclensions(nominative, genetive)\n          for (const declension of declensions) {\n            config.addWord(declension.word, { id, initial: { ...declension, development } })\n          }\n        }\n      }))\n    }"
+    },
+    {
+      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })\n    }"
+    },
     {
       "extraConfig": true,
       "operators": [
         "((hierarchy/*) [queryMarker|ne])",
-        "((listable/*) [listMarker|que])",
         "([hierarchiable])",
         "((hierarchiable) [hierarchy|] (hierarchiable))",
         "((hierarchiable) (hierarchiable) [hierarchy|])",
-        "([hierarchy|] (hierarchiable) (hierarchiable))"
+        "([hierarchy|] (hierarchiable) (hierarchiable))",
+        "(x [list|et] y)",
+        "((listable/*) [listMarker|que])"
       ],
       "bridges": [
+        {
+          "id": "inLatin",
+          "words": [
+            "in"
+          ],
+          "before": [
+            "iacere"
+          ],
+          "bridge": "{ ...next(operator), declension: 'inLatin', object: object, operator: operator, interpolate: [{ property: 'operator' }, { property: 'object' }] }",
+          "selector": {
+            "ordinals": [
+              1
+            ],
+            "arguments": {
+              "object": "(context.declension == 'accusative' || context.declension == 'ablative')"
+            }
+          }
+        },
+        {
+          "id": "iacere",
+          "level": 0,
+          "words": [
+            {
+              "word": "iacio",
+              "number": "singular",
+              "person": "first"
+            },
+            {
+              "word": "iacis",
+              "number": "singular",
+              "person": "second"
+            },
+            {
+              "word": "iacit",
+              "number": "singular",
+              "person": "third"
+            },
+            {
+              "word": "iacimus",
+              "number": "plural",
+              "person": "first"
+            },
+            {
+              "word": "iacitis",
+              "number": "plural",
+              "person": "second"
+            },
+            {
+              "word": "iaciunt",
+              "number": "plural",
+              "person": "third"
+            }
+          ],
+          "bridge": "{ ...next(operator), thrower: nominative?, receiver: dative?, object: object?, location: location?, interpolate: [{ property: 'thrower' }, { property: 'receiver' }, { property: 'location' }, { property: 'object' }, operator] }",
+          "selector": {
+            "arguments": {
+              "nominative": "(context.declension == 'nominative' && context.number == operator.number)",
+              "dative": "(context.declension == 'dative')",
+              "object": "(context.declension == 'accusative')",
+              "location": "(context.declension == 'inLatin')"
+            }
+          }
+        },
+        {
+          "id": "dare",
+          "level": 0,
+          "bridge": "{ ...next(operator), giver: nominative?, receiver: dative?, object: accusative?, interpolate: [{ property: 'giver' }, { property: 'receiver' }, { property: 'object' }, operator] }",
+          "selector": {
+            "arguments": {
+              "nominative": "(context.declension == 'nominative' && context.number == operator.number)",
+              "dative": "(context.declension == 'dative')",
+              "accusative": "(context.declension == 'accusative')"
+            }
+          },
+          "words": [
+            {
+              "word": "do",
+              "number": "singular",
+              "person": "first"
+            },
+            {
+              "word": "das",
+              "number": "singular",
+              "person": "second"
+            },
+            {
+              "word": "dat",
+              "number": "singular",
+              "person": "third"
+            },
+            {
+              "word": "damus",
+              "number": "plural",
+              "person": "first"
+            },
+            {
+              "word": "datis",
+              "number": "plural",
+              "person": "second"
+            },
+            {
+              "word": "dant",
+              "number": "plural",
+              "person": "third"
+            }
+          ]
+        },
+        {
+          "id": "list",
+          "level": 0,
+          "selector": {
+            "match": "same",
+            "left": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "right": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "passthrough": true
+          },
+          "bridge": "{ ...next(operator), listable: true, isList: true, value: append(before, after), operator: operator, interpolate: [ { separator: 'operator', values: 'value' } ] }"
+        },
+        {
+          "id": "list",
+          "level": 1,
+          "selector": {
+            "match": "same",
+            "left": [
+              {
+                "pattern": "($type && context.instance == variables.instance)"
+              }
+            ],
+            "passthrough": true
+          },
+          "bridge": "{ ...operator, value: append(before, operator.value) }"
+        },
         {
           "id": "queryMarker",
           "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], question: true }",
@@ -114,7 +408,7 @@
               "listable"
             ]
           ],
-          "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], list: true }",
+          "bridge": "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], isList: true }",
           "separators": "|"
         },
         {

package/common/latin.js

@@ -1,6 +1,7 @@
 const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const gdefaults = require("./gdefaults")
+const { conjugateVerb, getDeclensions } = require("./latin_helpers")
 const latin_tests = require('./latin.test.json')
 const latin_instance = require('./latin.instance.json')
 
@@ -11,17 +12,97 @@ const latin_instance = require('./latin.instance.json')
 
   estne
   marcus quintus iuliaque
+
+  oculi lupi in umbra lucent ut gemmae et dentes ut margaritae
+    oculi lupi in umbra lucent ut gemmae -> get this
+    dentes ut margaritae -> have these cases. reinterpret the first one uses the new cases oculi -> dentes + ut gemmae -> ut margaritae
+
+  equus et aninus leo et lupus canis et ovis bestiae sunt    
+  aliae bestiae sunt aves aliae pisces
+  moribus antiquis res stat romana virisque
+  fossa nimis lata et vallum nimis altum est
+  arma germanorium tam bona sunt nostra
+  hiems tempus frigidus est  (compound subject)
 */
 const config = {
   operators: [
     "((hierarchy/*) [queryMarker|ne])",
-    "((listable/*) [listMarker|que])",
     "([hierarchiable])",
     "((hierarchiable) [hierarchy|] (hierarchiable))",
     "((hierarchiable) (hierarchiable) [hierarchy|])",
     "([hierarchy|] (hierarchiable) (hierarchiable))",
+
+    "(x [list|et] y)",
+    "((listable/*) [listMarker|que])",
+
+    // "([inLatin|in] (context.declension == 'ablative' || context.declension == 'accusative'))"
   ],
   bridges: [
+    {
+      id: 'inLatin',
+      words: ['in'],
+      before: ['iacere'],
+      bridge: "{ ...next(operator), declension: 'inLatin', object: object, operator: operator, interpolate: [{ property: 'operator' }, { property: 'object' }] }",
+      selector: {
+        ordinals: [1],
+        arguments: {
+          object: "(context.declension == 'accusative' || context.declension == 'ablative')",
+        },
+      },
+    },
+    {
+      id: "iacere",
+      level: 0,
+      words: [
+        ...conjugateVerb('iacere'),
+      ],
+      bridge: "{ ...next(operator), thrower: nominative?, receiver: dative?, object: object?, location: location?, interpolate: [{ property: 'thrower' }, { property: 'receiver' }, { property: 'location' }, { property: 'object' }, operator] }",
+      selector: {
+        arguments: {
+          nominative: "(context.declension == 'nominative' && context.number == operator.number)",
+          dative: "(context.declension == 'dative')",
+          object: "(context.declension == 'accusative')",
+          location: "(context.declension == 'inLatin')",
+        },
+      },
+    },
+    {
+      id: "dare",
+      level: 0,
+      bridge: "{ ...next(operator), giver: nominative?, receiver: dative?, object: accusative?, interpolate: [{ property: 'giver' }, { property: 'receiver' }, { property: 'object' }, operator] }",
+      selector: {
+        arguments: {
+          nominative: "(context.declension == 'nominative' && context.number == operator.number)",
+          dative: "(context.declension == 'dative')",
+          accusative: "(context.declension == 'accusative')",
+        },
+      },
+      words: [
+        ...conjugateVerb('dare'),
+      ],
+    },
+    {
+      id: "list",
+      level: 0,
+      selector: {
+          match: "same",
+          left: [ { pattern: '($type && context.instance == variables.instance)' } ],
+          right: [ { pattern: '($type && context.instance == variables.instance)' } ],
+          passthrough: true
+      },
+      bridge: "{ ...next(operator), listable: true, isList: true, value: append(before, after), operator: operator, interpolate: [ { separator: 'operator', values: 'value' } ] }"
+    },
+    {
+      id: "list",
+      level: 1,
+      selector: {
+          match: "same",
+          left: [ { pattern: '($type && context.instance == variables.instance)' } ],
+          passthrough: true
+      },
+      bridge: "{ ...operator, value: append(before, operator.value) }"
+    },
+
     { 
       id: "queryMarker",
       bridge: "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], question: true }",
@@ -31,7 +112,7 @@ const config = {
     { 
       id: "listMarker",
       localHierarchy: [['unknown', 'listable']],
-      bridge: "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], list: true }",
+      bridge: "{ ...before[0], verb: before[0], interpolate: [before[0], '', operator], isList: true }",
       separators: '|',
     },
     { id: "hierarchiable" },
@@ -65,6 +146,24 @@ const config = {
 
 const template = {
   configs: [
+    ({config}) => {
+      config.addArgs(({config, api, isA}) => ({
+        addLatinNoun: ({ id, nominative, genetive, development }) => {
+          config.addOperator({ pattern: `([${id}|])`, development: development })
+          config.addBridge({ id, isA: ['hierarchiable'] })
+          const declensions = getDeclensions(nominative, genetive)
+          for (const declension of declensions) {
+            config.addWord(declension.word, { id, initial: { ...declension, development } })
+          }
+        }
+      }))
+    },
+    ({addLatinNoun}) => {
+      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })
+      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })
+      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })
+      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })
+    },
     config,
     ({addSuffix}) => addSuffix('que'),
   ]
@@ -72,6 +171,7 @@ const template = {
 
 knowledgeModule( { 
   config: { name: 'latin' },
+  // initializer,
   includes: [gdefaults],
 
   module,