engine.core — arete 0.6.0

alphas-by-wme-type clj

(alphas-by-wme-type rule-alpha-list)

build-lhs-exp clj

(build-lhs-exp rule)

build-rule clj

(build-rule network)

collect! clj

(collect! fun)

(collect! wme-type fun)

collect-nands clj

(collect-nands nodes idx)

collect-single-match-vars clj

(collect-single-match-vars omatch)

collect-vars-by-type clj

(collect-vars-by-type lhs)

context-value clj macro

(context-value key)

deep-get-all-obj-nodes clj

(deep-get-all-obj-nodes sub-net)

defancestor clj

(defancestor wme-type-seq ancestor)

defcontext clj macro

(defcontext {data :data
             before :before
             after :after
             :or {data {} before (constantly true) after (constantly true)}})

deforder clj macro

(deforder & funs)

defrule clj macro

(defrule & body)

enable-perf-mon clj

engine clj

(engine & modules)

extract-alphas clj

(extract-alphas rulesets)

extract-network clj

(extract-network rule)

find-any clj

(find-any vars sexp)

get-all-nand-nodes clj

(get-all-nand-nodes sub-net)

get-all-nodes-of-type clj

(get-all-nodes-of-type sub-net typ)

get-all-obj-nodes clj

(get-all-obj-nodes sub-net)

get-lhs-exp clj

(get-lhs-exp lhs)

get-match-exp clj

(get-match-exp omatch)

get-node-fields clj

(get-node-fields sub-net field-name)

get-priority clj

(get-priority rule)

get-rule-body clj

(get-rule-body rule)

get-stack-trace clj

(get-stack-trace)

get-upstream clj

(get-upstream nodes)

insert! clj

(insert! input-wme)

make-add-fun clj

(make-add-fun alpha-tests
              lhash-fun
              alpha-name
              rname-string
              wme-var
              oset
              ocur
              empty-count-name
              rule-name
              main-fun)

make-hash-funs clj

(make-hash-funs test-exp vars wme-var)

make-nand clj

(make-nand rname-string
           rule-name
           outer-names
           node
           nodes
           outer-vars
           vars
           outer-neg-index)

make-obj-node clj

(make-obj-node rname-string
               rule-name
               net-name
               outer-names
               empty-count-name
               x
               nodes
               vars
               outer-vars)

make-upstream-fun-no-beta-tests clj

(make-upstream-fun-no-beta-tests op-name
                                 uhash-exp
                                 ocur
                                 outer-vars
                                 vars
                                 upstream-node
                                 upstream-name
                                 outer-var-sublist
                                 sub-fun
                                 wme-var)

make-upstream-fun-with-beta-tests clj

(make-upstream-fun-with-beta-tests op-name
                                   uhash-exp
                                   ocur
                                   outer-vars
                                   vars
                                   beta-tests
                                   upstream-node
                                   upstream-name
                                   outer-var-sublist
                                   sub-fun
                                   wme-var
                                   rname-string)

node-defs clj

(node-defs node)

node-type clj

(node-type fnode)

order-sub-exps clj

(order-sub-exps test-exp vars)

ppwrap clj

(ppwrap tag val)

process-net clj

(process-net rname-str
             rule-name
             main-name
             outer-names
             priority
             empty-count
             rule-output-name
             rule-body
             outer-vars
             outer-neg-index)

remove! clj

(remove! wme)

translate-obj-test clj

(translate-obj-test x var)

type-and-descendents clj

(type-and-descendents wme-type)

update-all clj

(update-all in-map f)

wme-types clj macro

(wme-types wme)