;; in deps.edn
{:deps {github-akovantsev/rules
        {:git/url "https://github.com/akovantsev/rules"
         :sha     "87108b4fa2a0caceea1a59c284ac3baf38108819"}}} ;; actual sha

(def autoinc
   (r/rule ::foo                 ;; macro,  rule-id
     [:new id :x x < 5]          ;; find all ids whos :x is < 5
     [:let id :y y]              ;; join on id, where :y is not nil
     [:old id :x ox not= x]      ;; join on id, where prev :x val ≠ curr :x val

     :foreach                    ;; for each match {:id ... :x ... :y ...}:
     (prn :foreach1 match)       ;; print match map
     (r/change! id :x inc)       ;; ~ (update current-db id :x inc)

     :forall                     ;; once, for matches seq ({:id ... :x ... :y ...} ...):
     (println :once1 matches))) ;; print matches

; odoyle:
:what
[foo ::left-of bar {:then not=}]
[bar ::color color]

; rules:
[:new bar ::color color my-compare-with obar]
[:new foo ::left-of bar not= obar]
[:old foo ::left-of obar]

[tuple-type e a v]
[tuple-type e a v f & args]

; e.g when db changes from {1 {:a 1 :b 1}} to {1 {:a 2 :b 2}}
; change of any :a attribute in db does not trigger this rule,
; because it is not used in :new.
; only changes of :b in db trigger rule:
[:old id :a oa]              ;; :old uses :a, but :a change in db does not trigger rule
[:let id :a a not= (+ 1 oa)] ;; :let uses :a, but :a change in db does not trigger rule
[:new id :b b]               ;; :new uses :b, and any :b change in db triggers the rule

;;[type e a v f & args]:

[:new id :a a < b]  ;; -> (fn [{:as match, :syms [a b]}] (< a b))
[:new id :b b odd?]

[:new id :a a < b % (+ 10 id %)]  ;; -> (fn [{:as match, :syms [a b id]}] (< b a (+ 10 id a))
[:new id :b b]

...
[:new id :a a]
:foreach
(println db matches match)
(println id a)
;; => (fn [db matches {:as match, :syms [id a]}]
;;      (println db matches match)
;;      (println id a))

:forall
(println db)
(println matches)
;; => (fn [db matches]
;;      (println db)
;;      (println matches))