View difference between Paste ID: RZhWBbPz and RmFNC4rN

 ;; 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))
-(def completion-service (ExecutorCompletionService.
+
-	(Executors/newCachedThreadPool)))
+
 	(loop []
 		(print "Enter query: ") (flush)
 		(let [query (read-line)
-		(loop []
+
-			(if (not (nil? (.poll completion-service)))
+
-				(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))))))
-			(do
+
 (defn solve-rule [rule-tail]
-					(.submit completion-service #(solve-rule rule)))
+
-				(.get (.take completion-service))))))
+		(apply + truths)))		; sum up truth values -- for testing