logging

Added najure.actors namespace and tidied up ns declarations

.gitignore

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

project.clj

@@ -3,16 +3,22 @@
   :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.8.0"]
+  :dependencies [[org.clojure/clojure "1.7.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"]]
+                 [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"]]
   :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}})
+  :profiles {:uberjar {:aot :all}}
+  :jvm-opts ["-Dco.paralleluniverse.fibers.detectRunawayFibers=false"])

resources/narsese.bnf

@@ -5,7 +5,7 @@
          sentence ::= statement"." [tense] [truth]            (* judgement to be remembered *)
                     | statement"?" [tense] [truth]            (* question to be answered, tense added in OpenNARS 1.7 *)
                     | statement"@" [tense] [truth]            (* question on desire value to be answered, tense added in OpenNARS 1.7 *)
-                    | statement"!" [tense] [truth]            (* goal to be realized, tense added in OpenNARS 1.7 *)
+                    | statement"!" [tense] [desire]           (* goal to be realized, tense added in OpenNARS 1.7 *)
 
         statement ::= <"<">term copula term<">">              (* two terms related to each other *)
                     | <"(">term copula term<")">              (* two terms related to each other, new notation *)
@@ -15,15 +15,15 @@
 
            copula ::= "-->"                                   (* inheritance *)
                     | "<->"                                   (* similarity *)
-                    | "{--"                                   (* instance *)
-                    | "--]"                                   (* property *)
-                    | "{-]"                                   (* instance-property *)
+                    | "{--"                                   (* o-- instance *)
+                    | "--]"                                   (* --o property *)
+                    | "{-]"                                   (* o-o instance-property *)
                     | "==>"                                   (* implication *)
-                    | "=/>"                                   (* predictive implication *)
+                    | "=/>"                                   (* =+> predictive implication *)
                     | "=|>"                                   (* concurrent implication *)
-                    | "=\\>"                                  (* =\> retrospective implication *)
+                    | "=\\>"                                  (* =-> retrospective implication *)
                     | "<=>"                                   (* equivalence *)
-                    | "</>"                                   (* predictive equivalence *)
+                    | "</>"                                   (* <+> predictive equivalence *)
                     | "<|>"                                   (* concurrent equivalence *)
 
              term ::= word                                    (* an atomic constant term *)
@@ -72,6 +72,7 @@
          interval ::= <"/">#"\d+"                             (* integer *)
 
             truth ::= <"%">frequency[<";">confidence]<"%">    (* two numbers in [0,1]x(0,1) *)
+           desire ::= <"%">plausibility[<";">desirability]<"%"> (* two numbers in [0,1]x(0,1) *)
            budget ::= <"$">priority[<";">durability][<";">quality]<"$"> (* three numbers in [0,1]x(0,1)x[0,1] *)
 
                word : #"\w+"                                  (* unicode string *)    
@@ -80,3 +81,6 @@
             quality : #"([0]?\.[0-9]+|1\.[0]*|1|0)"           (* 0 <= x <= 1 *)
           frequency : #"([0]?\.[0-9]+|1\.[0]*|1|0)"           (* 0 <= x <= 1 *)
          confidence : #"[0]?\.[0]*[1-9]{1}[0-9]*"             (* 0 <  x <  1 *)
+       plausibility : #"([0]?\.[0-9]+|1\.[0]*|1|0)"           (* 0 <= x <= 1 *)
+       desirability : #"[0]?\.[0]*[1-9]{1}[0-9]*"             (* 0 <  x <  1 *)
+

src/narjure/actor/active_concept_collator.clj

@@ -0,0 +1,28 @@
+(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

@@ -0,0 +1,36 @@
+(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

@@ -0,0 +1,34 @@
+(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

@@ -0,0 +1,38 @@
+(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

@@ -0,0 +1,29 @@
+(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

@@ -0,0 +1,26 @@
+(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

@@ -0,0 +1,27 @@
+(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

@@ -0,0 +1,24 @@
+(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

@@ -0,0 +1,31 @@
+(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

@@ -0,0 +1,22 @@
+(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

@@ -0,0 +1,43 @@
+(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

@@ -0,0 +1,23 @@
+(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

@@ -0,0 +1,37 @@
+(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

@@ -0,0 +1,19 @@
+(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,8 +1,144 @@
 (ns narjure.core
-    (:require [instaparse.core :as insta])
-    (:gen-class))
+  (: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))
 
-(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%"))
+(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)))

src/narjure/cycle.clj

@@ -117,7 +117,7 @@
       (update-in c [:answers q] choice-with-nil belief))
     concept questions))
 
-(defmulti task->concept (fn [& args] (:action (first args))))
+(defmulti task->concept (fn [& args] (:task-type (first args))))
 
 (defmethod task->concept :question
   [{:keys [statement] :as task} {:keys [concepts] :as m} term]

src/narjure/narsese.clj

@@ -40,16 +40,23 @@
    "&/" 'sequential-events
    "&|" 'parallel-events})
 
+(def tenses
+  {":|:"  :present
+   ":/:"  :future
+   ":\\:" :past})
+
 (defn get-compound-term [[_ operator-srt]]
   (compound-terms operator-srt))
 
-(def actions {"." :judgement
-              "?" :question})
+(def task-types {"." :judgement
+                 "?" :question})
 
-(def ^:dynamic *action* (atom nil))
+(def ^:dynamic *task-type* (atom nil))
 (def ^:dynamic *lvars* (atom []))
 (def ^:dynamic *truth* (atom []))
 (def ^:dynamic *budget* (atom []))
+(def ^:dynamic *tense* (atom :present))
+(def ^:dynamic *syntactic-complexity* nil)
 
 (defn keep-cat [fun col]
   (into [] (comp (mapcat fun) (filter (complement nil?))) col))
@@ -64,16 +71,20 @@
 
 (defmethod element :sentence [[_ & data]]
   (let [filtered (group-by string? data)]
-    (reset! *action* (actions (first (filtered true))))
+    (reset! *task-type* (task-types (first (filtered true))))
     (let [cols (filtered false)
           last-el (last cols)]
       (when (= :truth (first last-el))
         (element last-el))
+      (when-let [tense (some #(when (= :tense (first %)) %) data)]
+        (element tense))
       (element (first cols)))))
 
 (defmethod element :statement [[_ & data]]
   (if-let [copula (get-copula data)]
-    `[~copula ~@(keep-cat element data)]
+    (do
+      (swap! *syntactic-complexity* inc)
+      `[~copula ~@(keep-cat element data)])
     (keep-cat element data)))
 
 (defmethod element :task [[_ & data]]
@@ -125,9 +136,13 @@
   (element (last data)))
 
 (defmethod element :term [[_ & data]]
+  (swap! *syntactic-complexity* inc)
   (when (seq? data)
     (keep element data)))
 
+(defmethod element :tense [[_ key]]
+  (reset! *tense* (tenses key)))
+
 (defmethod element :default [_])
 
 ;TODO check for variables in statemnts, ignore subterm if it contains variable
@@ -148,16 +163,20 @@
   [narsese-str]
   (let [data (parser narsese-str)]
     (if-not (i/failure? data)
-      (binding [*action* (atom nil)
+      (binding [*task-type* (atom nil)
                 *lvars* (atom [])
                 *truth* (atom [])
-                *budget* (atom [])]
+                *budget* (atom [])
+                *tense* (atom :present)
+                *syntactic-complexity* (atom 0)]
         (let [statement (element data)
-              act @*action*]
-          {:action    act
-           :lvars     @*lvars*
-           :truth     (check-truth-value @*truth*)
-           :budget    (check-budget @*budget* act)
-           :statement statement
-           :terms     (terms statement)}))
+              act @*task-type*]
+          {:task-type            act
+           :lvars                @*lvars*
+           :truth                (check-truth-value @*truth*)
+           :budget               (check-budget @*budget* act)
+           :statement            statement
+           :tense                @*tense*
+           :syntactic-complexity @*syntactic-complexity*
+           :terms                (terms statement)}))
       data)))