The the-sequence-is-key from maersdal

Custom interceptor support

The error catching mechanism is conj'ing onto a list of errors

What about custom interceptor support, so that any user can inject whatever mechanism is nessecary?

Infinite streams

For now, the error catching mechanism is conj'ing onto a list of errors, then this list of errors is displayed in the final output.

To be able to use the verification with infinite streams, it should probably subscribe to a stream somehow, and have an atom of errors

machine reducing functions are overly complex

the-sequence-is-key/src/sequence/engine/machine.clj

Lines 82 to 137 in 82d6172

 (defn rule-reduce 

 ([active-rules clause k] 

 (rule-reduce active-rules clause k false)) 

 ([active-rules clause k immediate] 

 (reduce (fn [arules kvp] 

 (let [[rule value] kvp 

 ;_ (println arules kvp) 

 ] 

 (case rule 

 ::not-eventually (if (and (= value k) (not immediate)) 

 (update arules ::problem conj {:rule [::not-eventually value] 

 :broken-by k 

 ::position (active-rules ::position)}) 

 arules) 

 ::is-after (if-not (contains? active-rules value) 

 (update arules ::problem conj {:rule [::is-after value] 

 :broken-by k 

 ::position (active-rules ::position)}) 

 arules) 

 ::relax (apply dissoc arules value) 

 ::next (assoc arules ::next value) 

 ::free arules 

 :default (update arules ::problem conj 

 {:rule [::not-implemented rule value] 

 ::position (active-rules ::position)})))) 

 active-rules clause))) 

 (defn rule-reduce-immediate [rules clause k] 

 (rule-reduce rules clause k true)) 

 (defn inc-or-zero [x] 

 (if-not (nil? x) 

 (inc x) 

 0)) 

 (def rule-parsing-default {::position 0}) 

 (defn rule-parsing [all-rules active-rules k] 

 (when debugprint 

 (println active-rules k)) 

 ;; next is priority rule! 

 (if-let [target (active-rules ::next)] 

 (if-not (= k (active-rules ::next)) 

 (update active-rules ::problem conj {:rule [::next target] 

 :broken-by k 

 ::position (active-rules ::position)}) 

 (rule-parsing all-rules (dissoc active-rules ::next) k)) 

 ;; 

 (if (contains? active-rules k) 

 (let [clause (active-rules k)] 

 (update (rule-reduce active-rules clause k) 

 ::position inc-or-zero)) 

 (let [clause (all-rules k)] 

 (-> (rule-reduce-immediate active-rules clause k) 

 (assoc k clause) 

 (update ::position inc-or-zero))))))

Need to be able to define a-priori rules, which are not needed to be triggered

for example ::eventually should be able to be defined in the pre rules, and defining it on a trigger might not make sense

maersdal / the-sequence-is-key Goto Github PK

the-sequence-is-key's People

Contributors

Watchers

the-sequence-is-key's Issues

Custom interceptor support

Infinite streams

machine reducing functions are overly complex

Need to be able to define a-priori rules, which are not needed to be triggered

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	(defn rule-reduce
	([active-rules clause k]
	(rule-reduce active-rules clause k false))
	([active-rules clause k immediate]
	(reduce (fn [arules kvp]
	(let [[rule value] kvp
	;_ (println arules kvp)
	]
	(case rule
	::not-eventually (if (and (= value k) (not immediate))
	(update arules ::problem conj {:rule [::not-eventually value]
	:broken-by k
	::position (active-rules ::position)})
	arules)
	::is-after (if-not (contains? active-rules value)
	(update arules ::problem conj {:rule [::is-after value]
	:broken-by k
	::position (active-rules ::position)})
	arules)
	::relax (apply dissoc arules value)
	::next (assoc arules ::next value)
	::free arules
	:default (update arules ::problem conj
	{:rule [::not-implemented rule value]
	::position (active-rules ::position)}))))
	active-rules clause)))

	(defn rule-reduce-immediate [rules clause k]
	(rule-reduce rules clause k true))

	(defn inc-or-zero [x]
	(if-not (nil? x)
	(inc x)
	0))

	(def rule-parsing-default {::position 0})

	(defn rule-parsing [all-rules active-rules k]
	(when debugprint
	(println active-rules k))
	;; next is priority rule!
	(if-let [target (active-rules ::next)]
	(if-not (= k (active-rules ::next))
	(update active-rules ::problem conj {:rule [::next target]
	:broken-by k
	::position (active-rules ::position)})
	(rule-parsing all-rules (dissoc active-rules ::next) k))
	;;
	(if (contains? active-rules k)
	(let [clause (active-rules k)]
	(update (rule-reduce active-rules clause k)
	::position inc-or-zero))
	(let [clause (all-rules k)]
	(-> (rule-reduce-immediate active-rules clause k)
	(assoc k clause)
	(update ::position inc-or-zero))))))