:goal and :quest task types

.gitignore

@@ -13,5 +13,4 @@ pom.xml.asc
 *.iml
 *~
 \#*\#
-.\#*
-*experiments.clj
+.\#*

project.clj

@@ -3,22 +3,16 @@
   :url "https://github.com/jarradh/narjure"
   :license {:name "GNU General Public License 2.0"
             :url  "http://www.gnu.org/licenses/old-licenses/gpl-2.0.html"}
-  :dependencies [[org.clojure/clojure "1.7.0"]
+  :dependencies [[org.clojure/clojure "1.8.0"]
                  [org.clojure/core.logic "0.8.10"]
                  [instaparse "1.4.1"]
                  [com.rpl/specter "0.9.1"]
                  [org.clojure/tools.nrepl "0.2.12"]
-                 [org.clojure/data.priority-map "0.0.7"]
-                 [co.paralleluniverse/pulsar "0.7.4"]
-                 [org.immutant/immutant "2.1.2"]
-                 [clj-time "0.11.0"]
-                 [com.taoensso/timbre "4.3.1"]]
-  :java-agents [[co.paralleluniverse/quasar-core "0.7.4"]]
+                 [org.clojure/data.priority-map "0.0.7"]]
   :main ^:skip-aot narjure.core
   :plugins [[lein-cloverage "1.0.6"]
             [cider/cider-nrepl "0.11.0-SNAPSHOT"]]
   :target-path "target/%s"
   :repl-options {:init-ns          narjure.repl
                  :nrepl-middleware [narjure.repl/narsese-handler]}
-  :profiles {:uberjar {:aot :all}}
-  :jvm-opts ["-Dco.paralleluniverse.fibers.detectRunawayFibers=false"])
+  :profiles {:uberjar {:aot :all}})

src/narjure/actor/active_concept_collator.clj

@@ -1,28 +0,0 @@
-(ns narjure.actor.active-concept-collator
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare process active-concept-collator)
-
-(def aname :active-concept-collator)
-
-(defsfn active-concept-collator
-  "State is collection of active concepts."
-  []
-  (register! aname @self)
-  (set-state! [])
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :inference-tick-msg [_ _]
-  ;(debug aname "process-inference-tick")
-  [])
-
-(defmethod process :active-concept-msg [_ _]
-  (debug aname "process-active-concept"))

src/narjure/actor/anticipated_event.clj

@@ -1,36 +0,0 @@
-(ns narjure.actor.anticipated-event
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self !]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare anticipated-event process)
-
-(def aname :anticipated-event)
-
-(defsfn anticipated-event
-  "State is system-time and collection of anticipated events."
-  []
-  (register! aname @self)
-  (set-state! {:time 0 :anticipated-events {}})
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :system-time-msg
-  [[_ time] state]
-  (debug aname "process-system-time")
-  {:time time :anticipated-events (state :percepts)})
-
-(defmethod process :anticipated-event-msg
-  [_ _]
-  #_(debug aname "process-anticipated-event"))
-
-(defmethod process :input-task-msg
-  [[_ input-task] _]
-  #_(debug aname "process-input-task")
-  (! :task-dispatcher [:task-msg input-task]))
-

src/narjure/actor/concept.clj

@@ -1,34 +0,0 @@
-(ns narjure.actor.concept
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state!]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :as t])
-  (:refer-clojure :exclude [promise await]))
-
-(declare concept process)
-
-(defsfn concept
-  "State is a map
-  {:name :budget :activation-level :belief-tab :goal-tab :task-bag :term-bag}
-  (this list may not be complete)."
-  []
-  (set-state! {})
-  (actor-loop :concept process))
-
-(defhandler process)
-
-(defn debug [msg] (t/debug :concept msg))
-
-(defmethod process :task [_ _]
-  #_(debug "process-task"))
-
-(defmethod process :belief-req [_ _]
-  (debug "process-belief-req"))
-
-(defmethod process :inference-req [_ _]
-  (debug "process-inference-req"))
-
-(defmethod process :persistence-req [_ _]
-  (debug "process-persistence-req"))

src/narjure/actor/concept_creator.clj

@@ -1,38 +0,0 @@
-(ns narjure.actor.concept-creator
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self ! spawn]]]
-    [narjure.actor.concept :refer [concept]]
-    [narjure.actor.utils :refer [actor-loop]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare concept-creator process-task)
-
-(def aname :concept-creator)
-
-(defsfn concept-creator
-  []
-  (register! aname @self)
-  (actor-loop aname process-task))
-
-(defn create-concept
-  ;TODO: update state for concept-actor to state initialiser
-  ;TODO: Create required sub-term concepts and propogate budget
-  [task c-map]
-  (let [{term :term} task]
-    (swap! c-map assoc term (spawn concept))
-    #_(debug aname (str "Created concept: " term))))
-
-(defn process-task
-  "When concept-map does not contain :term, create concept actor for term
-   then post task to task-dispatcher either way."
-  [[_ from task c-map] _]
-  (let [term (task :term)]
-    ; when concept not exist then create - goes here
-    (when (not (contains? @c-map term))
-      (create-concept task c-map)))
-
-  (! from [:task-msg task])
-  #_(debug aname "concept-creator - process-task"))

src/narjure/actor/cross_modal_integrator.clj

@@ -1,29 +0,0 @@
-(ns narjure.actor.cross-modal-integrator
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare cross-modal-integrator process)
-
-(def aname :cross-modal-integrator)
-
-(defsfn cross-modal-integrator
-  "State is system-time and collection of precepts from current duration window."
-  []
-  (register! :cross-modal-integrator @self)
-  (set-state! {:time 0 :percepts []})
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :system-time [[_ time] state]
-  (debug aname "process-system-time")
-  {:time time :percepts (state :percepts)})
-
-(defmethod process :percept-sentence [_ _]
-  (debug aname "process-percept-sentence"))
-

src/narjure/actor/derived_task_creator.clj

@@ -1,26 +0,0 @@
-(ns narjure.actor.derived-task-creator
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare derived-task-creator process)
-
-(def aname :derived-task-creator)
-
-(defsfn derived-task-creator
-  "State is system-time."
-  []
-  (register! aname @self)
-  (set-state! {:time 0})
-  (actor-loop aname process))
-
-(defn process-system-time [[_ time] _]
-  (debug aname "process-system-time")
-  {:time time})
-
-(defn process-inference-result [_ _]
-  (debug aname "process-inference-result"))

src/narjure/actor/forgettable_concept_collator.clj

@@ -1,27 +0,0 @@
-(ns narjure.actor.forgettable-concept-collator
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare forgettable-concept-collator process)
-
-(def aname :forgettable-concept-collator)
-
-(defsfn forgettable-concept-collator
-  "State is collection of forgettable concepts."
-  []
-  (register! :forgettable-concept-collator @self)
-  (set-state! [])
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :forgetting-tick-msg [_ _]
-  #_(debug aname "process-forgetting-tick"))
-
-(defmethod process :forgettable-concept-msg [_ _]
-  (debug aname "process-forgettable-concept"))

src/narjure/actor/general_inferencer.clj

@@ -1,24 +0,0 @@
-(ns narjure.actor.general-inferencer
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare general-inferencer do-inference)
-
-(def aname :general-inferencer)
-
-(defsfn general-inferencer
-  "state is inference rule trie or equivalent"
-  []
-  (register! aname @self)
-  (set-state! {:trie 0})
-  (actor-loop aname do-inference))
-
-(defn do-inference [_ _]
-  (debug aname "process-do-inference"))
-
-

src/narjure/actor/operator_executor.clj

@@ -1,31 +0,0 @@
-(ns narjure.actor.operator-executor
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare operator-executor process)
-
-(def aname :operator-executor)
-
-(defsfn operator-executor
-  "state is system-time"
-  []
-  (register! aname @self)
-  (set-state! {:time 0})
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :system-time-msg [[_ time] _]
-  (debug aname "process-system-time")
-  {:time time})
-
-(defmethod process :operator-execution-req-msg [_ _]
-  (debug aname "process-operator-execution-req"))
-
-
-

src/narjure/actor/persistence_manager.clj

@@ -1,22 +0,0 @@
-(ns narjure.actor.persistence-manager
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare concept-state persistence-manager)
-
-(def aname :persistence-manager)
-
-(defsfn persistence-manager
-  "state is file system handles"
-  [in-state]
-  (register! aname @self)
-  (set-state! in-state)
-  (actor-loop aname concept-state))
-
-(defn concept-state [_ _]
-  (debug aname "process-concept-state"))

src/narjure/actor/sentence_parser.clj

@@ -1,43 +0,0 @@
-(ns narjure.actor.sentence-parser
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self !]]]
-    [narjure.narsese :refer [parse]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug info]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare sentence-parser process)
-
-(def aname :sentence-parser)
-
-(def serial-no (atom 0))
-
-(defsfn sentence-parser
-  []
-  (register! aname @self)
-  (set-state! {:time 0})
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :system-time-msg [[_ time] _]
-  (debug aname "process-system-time")
-  {:time time})
-
-(defn parse-task
-  "Parses a narsese string."
-  [string system-time]
-  (assoc (parse string)
-    :stamp
-    {:id              (swap! serial-no inc)
-     :creation-time   system-time
-     :occurrence-time system-time
-     :trail           [serial-no]}))
-
-(defmethod process :narsese-string-msg
-  [[_ string] {time :time}]
-  (let [task (parse-task string time)]
-    (! :anticipated-event [:input-task-msg task])
-    (info aname (str "process-narsese-string" task))))

src/narjure/actor/system_time.clj

@@ -1,23 +0,0 @@
-(ns narjure.actor.system-time
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self]]]
-    [narjure.actor.utils :refer [actor-loop]]
-    [taoensso.timbre :refer [debug]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare system-time system-time-tick)
-
-(def aname :system-time)
-
-(defsfn system-time
-  "state is system-time"
-  []
-  (register! aname @self)
-  (set-state! 0)
-  (actor-loop aname system-time-tick))
-
-(defn system-time-tick [_ state]
-  ;(debug aname (str "process-system-time-tick " state))
-  (inc state))

src/narjure/actor/task_dispatcher.clj

@@ -1,37 +0,0 @@
-(ns narjure.actor.task-dispatcher
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer [defsfn]]
-     [actors :refer [register! set-state! self ! whereis]]]
-    [narjure.actor.utils :refer [actor-loop defhandler]]
-    [taoensso.timbre :refer [debug info]])
-  (:refer-clojure :exclude [promise await]))
-
-(declare task-dispatcher process)
-
-(def aname :task-dispatcher)
-(def c-map (atom {}))
-
-(defsfn task-dispatcher
-  "concept-map is atom {:term :actor-ref} shared between
-         task-dispatcher and concept-creator"
-  []
-  (register! aname @self)
-  (actor-loop aname process))
-
-(defhandler process)
-
-(defmethod process :task-msg
-  [[_ input-task] _]
-  (let [concept-creator (whereis :concept-creator)
-        term (input-task :term)]
-    (if-let [concept (@c-map term)]
-      (! concept :task-msg input-task)
-      (! concept-creator [:create-concept-msg @self input-task c-map])))
-  #_(debug aname (str "process-task" input-task)))
-
-(defmethod process :forget-concept-msg [[_ forget-concept] _]
-  (debug aname "process-forget-concept"))
-
-(defmethod process :concept-count-msg [_ _]
-  (info aname (format "Concept count[%s]" (count @c-map))))

src/narjure/actor/utils.clj

@@ -1,19 +0,0 @@
-(ns narjure.actor.utils
-  (:require
-    [co.paralleluniverse.pulsar
-     [actors :refer [set-state! state receive !]]]
-    [taoensso.timbre :refer [debug]]))
-
-(defmacro defhandler [name]
-  `(do
-     (defmulti ~name (fn [[t#] c#] t#))
-     (defmethod ~name :default [a# b#] :unhandled)))
-
-(defmacro actor-loop [name f]
-  `(loop []
-     (let [msg# (receive)
-           result# (~f msg# @state)]
-       (if (= :unhandled result#)
-         (debug ~name (str "unhandled msg:" msg#))
-         (set-state! result#))
-       (recur))))

src/narjure/core.clj

@@ -1,144 +1,8 @@
 (ns narjure.core
-  (:require
-    [co.paralleluniverse.pulsar
-     [core :refer :all]
-     [actors :refer :all]]
-    [immutant.scheduling :refer :all]
-    [narjure.actor
-     [active-concept-collator :refer [active-concept-collator]]
-     [anticipated-event :refer [anticipated-event]]
-     [concept-creator :refer [concept-creator]]
-     [cross-modal-integrator :refer [cross-modal-integrator]]
-     [derived-task-creator :refer [derived-task-creator]]
-     [forgettable-concept-collator :refer [forgettable-concept-collator]]
-     [general-inferencer :refer [general-inferencer]]
-     [operator-executor :refer [operator-executor]]
-     [persistence-manager :refer [persistence-manager]]
-     [sentence-parser :refer [sentence-parser]]
-     [system-time :refer [system-time]]
-     [task-dispatcher :refer [task-dispatcher]]]
-    [taoensso.timbre :refer [info set-level!]])
-  (:refer-clojure :exclude [promise await])
-  (:import (ch.qos.logback.classic Level)
-           (org.slf4j LoggerFactory))
-  (:gen-class))
+    (:require [instaparse.core :as insta])
+    (:gen-class))
 
-(set-level! :info)
-(doseq [logger ["co.paralleluniverse.actors.JMXActorMonitor"
-                "org.quartz.core.QuartzScheduler"
-                "co.paralleluniverse.actors.LocalActorRegistry"
-                "co.paralleluniverse.actors.ActorRegistry"
-                "org.projectodd.wunderboss.scheduling.Scheduling"]]
-  (.setLevel (LoggerFactory/getLogger logger) Level/OFF))
-
-;co.paralleluniverse.actors.JMXActorMonitor
-(def actors-names
-  #{:active-concept-collator
-    :anticipated-event
-    :concept-creator
-    :cross-modal-integrator
-    :derived-task-creator
-    :forgettable-concept-collator
-    :general-inferencer
-    :operator-executor
-    :persistence-manager
-    :sentence-parser
-    :system-time
-    :task-dispatcher})
-
-(defn create-system-actors
-  "Spawns all actors which self register!"
-  []
-  (spawn active-concept-collator)
-  (spawn anticipated-event)
-  (spawn concept-creator)
-  (spawn cross-modal-integrator)
-  (spawn derived-task-creator)
-  (spawn forgettable-concept-collator)
-  (spawn general-inferencer)
-  (spawn operator-executor)
-  (spawn persistence-manager :state)
-  (spawn sentence-parser)
-  (spawn system-time)
-  (spawn task-dispatcher))
-
-(defn check-actor [actor-name]
-  (info (if (whereis actor-name) "\t[OK]" "\t[FAILED]") (str actor-name)))
-
-(defn check-actors-registered []
-  (info "Checking all services are registered...")
-  (doseq [actor-name actors-names]
-    (check-actor actor-name))
-  (info "All services registered."))
-
-(def inference-tick-interval 2500)
-(def forgetting-tick-interval 3000)
-(def system-tick-interval 2000)
-
-(defn inference-tick []
-  (! :active-concept-collator [:inference-tick-msg]))
-
-(defn forgetting-tick []
-  (! :forgettable-concept-collator [:forgetting-tick-msg]))
-
-(defn system-tick []
-  (! :system-time [:system-time-tick-msg]))
-
-(defn prn-ok [msg] (info (format "\t[OK] %s" msg)))
-
-(defn start-timers []
-  (info "Initialising system timers...")
-  (schedule inference-tick {:in    inference-tick-interval
-                            :every inference-tick-interval})
-  (prn-ok :system-timer)
-
-  (schedule forgetting-tick {:in    forgetting-tick-interval
-                             :every forgetting-tick-interval})
-  (prn-ok :forgetting-timer)
-
-  (schedule system-tick {:every system-tick-interval})
-  (prn-ok :inference-timer)
-
-  (info "System timer initialisation complete."))
-
-(defn start-nars [& _]
-  (info "NARS initialising...")
-
-  ; spawn all actors except concepts
-  (create-system-actors)
-  ; allow delay for all actors to be initialised
-  (sleep 1 :sec)
-  (check-actors-registered)
-  (start-timers)
-
-  ; update user with status
-  (info "NARS initialised.")
-
-  ; *** Test code
-  (let [task-dispatcher (whereis :task-dispatcher)]
-    (info "Beginning test...")
-    (time
-      (loop [n 0]
-        (when (< n 1000000)
-          ; select approximately 90% from existing concepts
-          (let [n1 (if (< (rand) 0.01) n (rand-int (/ n 10)))]
-            (! task-dispatcher [:task-msg {:term  (format "a --> %d" n1)
-                                           :other "other"}])
-            (when (== (mod n 100000) 0)
-              (info (format "processed [%s] messages" n))))
-          (recur (inc n))))))
-  ; allow delay for all actors to process their queues
-  (Thread/sleep 100)
-  (info "Test complete.")
-  ; *** End test code
-
-  ; join all actors so the terminate cleanly
-  (doseq [actor-name actors-names]
-    (join (whereis actor-name)))
-
-  ; cancel schedulers
-  (stop))
-
-; call main function
-(defn run []
-  (future (start-nars)))
+(defn -main
+  "I don't do a whole lot ... yet."
+  [& args]
+  ((insta/parser (clojure.java.io/resource "narsese.bnf") :auto-whitespace :standard) "<bird --> swimmer>. %0.10;0.60%"))

src/narjure/narsese.clj

@@ -49,7 +49,9 @@
   (compound-terms operator-srt))
 
 (def task-types {"." :judgement
-                 "?" :question})
+                 "?" :question
+                 "@" :quest
+                 "!" :goal})
 
 (def ^:dynamic *task-type* (atom nil))
 (def ^:dynamic *lvars* (atom []))