macros are weird.

clpfd.clj

(def a (lg/lvar 'a))
(def b (lg/lvar 'b))
(def lvars [a b])

;simple attempt:
(lg/run* [q]
  (fd/in a b (fd/interval 0 1))
  (lg/== q lvars))
; this gives me the answer i want --> ([0 0] [0 1] [1 0] [1 1])

;more complicated:
(lg/run* [q]
  (doseq [lvar lvars]
    (fd/in lvar (fd/interval 0 1)))
  (lg/== q lvars))

;this gives a null pointer exception
;i think it is because of how the run* macro is implemented.  i am confused, because the goals are basically side-effect-producing.



;this is frustrating because I want to **programatically generate constraints**, which will be a pain if I can't use doseq.


;here is another failed attempt:
(defn bind-them [[lvar & lvars]]
  (fd/in lvar (fd/interval 0 1))
  (if (not (empty? lvars))
    (recur (rest lvars))))

(lg/run* [q]
  (bind-them lvars)
  (lg/== q lvars))


;do you understand why the null pointer exception?
;i suppose the macro is my only option: trick the macro into thinking i've given it a list of explicit commands..?

I think the confusing part is that goals are not side-effecting. They have to be combined with all (implicit inside a run* or fresh) or conde. You can manage this with recursion, in general. In the case of all there's a helper built in called everyg.

E.g., bind-them could be defined:

(defn bind-them [[lvar & lvars]]
  (all
    (fd/in lvar (fd/interval 0 1))
    (if (seq lvars)
      (bind-them lvars) ;; cannot use recur here
      s#)))

or easier using everyg:

(defn bind-them [lvars]
  (everyg #(fd/in % (fd/interval 0 1)) lvars))

and at this point it's so short you may as well inline it.

Hey, thanks a lot

that `s# is crazy.