backward chaining in Clojure

;; Backward chaining in Clojure
;; -- implemented as a parallel search
;; -- the search tree interleaves calling of solve-goal and solve-rule
;; -- solveGoals takes the first result available (OR)
;; -- solveRules collects all results before calculating an answer (AND)
;; -- technically this is called an AND-OR tree

(ns backward)
(import '(java.util.concurrent Executors ExecutorCompletionService))

(declare start solve-goal solve-rule collect unify)

;; Choose between using parallel collect or sequential collect.
(def use-parallel-collect true)
(def collect (if use-parallel-collect pmap map))

(defn start []
    (loop []
        (print "Enter query: ") (flush)
        (let [query (read-line)
              truth (solve-goal (symbol query))]
            (printf "Answer is: %s\n" truth))
        (recur)))

;; The rule base
(defn fetch-rules [goal]
    (case goal
        g '[[a,b,c],[d,e,f]]
        a '[[e,f]]
        b '[[c,d,e,f]]
        c '[[e,f]]
        d '[[e,f]]
        e '[[]]
        f '[[]]
        true (throw (Exception. "No applicable rule"))))

(defn solve-goal [goal]
    (let [rules (fetch-rules goal)]
        (if (some empty? rules)
            1.0     ; return a truth value
            (let [comp-service (ExecutorCompletionService.
                    (Executors/newCachedThreadPool))]
                (doseq [rule rules]
                    (.submit comp-service #(solve-rule rule)))
                (.get (.take comp-service))))))

(defn solve-rule [rule-tail]
    (let [truths (collect solve-goal rule-tail)]
        (apply + truths)))      ; sum up truth values -- for testing