View difference between Paste ID: G9QhADgm and 5g3fjeN0

-;; Backward Chaining
+%% Backward chaining
 
-(ns backward)
+-module(backward).
-(import '(java.util.concurrent Executors ExecutorCompletionService))
+-export([start/0,mainLoop/0,solveGoal/2,solveRule/2,collect/3]).
 
-(declare start solve-goal solve-rule collect unify)
+start() ->
 	%% Initialize KB
-; Choose between using parallel collect or sequential collect.
+	ets:new(rules, [bag, named_table]),
-(def use-parallel-collect true)
+	ets:insert(rules, {g,[d,e,f,h,i,j],1.0}),
 	ets:insert(rules, {g,[a,b,c],1.1}),
-(def completion-service (ExecutorCompletionService.
+	ets:insert(rules, {a,[],0.1}),
-	(Executors/newCachedThreadPool)))
+	ets:insert(rules, {b,[],0.2}),
 	ets:insert(rules, {c,[],0.3}),
-(defn start []
+	ets:insert(rules, {d,[],0.4}),
-	(loop []
+	ets:insert(rules, {e,[],0.5}),
-		(print "Enter query: ") (flush)
+	ets:insert(rules, {f,[],0.6}),
-		(let [query (read-line)
+	ets:insert(rules, {h,[],0.7}),
-			truth (solve-goal (symbol query))]
+	ets:insert(rules, {i,[],0.8}),
-			(printf "Answer is: %s\n" truth))
+	ets:insert(rules, {j,[],0.9}),
-		(recur)))
+	mainLoop().
 
-(defn fetch-rules [goal]
+mainLoop() ->
-	(case goal
+	Query = io:read("Enter query: "),
-		g '[[a,b,c],[d,e,f]]
+	solveGoal(element(2, Query), self()),
-		a '[[e,f]]
+	receive
-		b '[[c,d,e,f]]
+		{_, Truth} -> io:format("Answer is: ~w~n", [Truth])
-		c '[[e,f]]
+	end,
-		d '[[e,f]]
+	mainLoop().
-		e '[[]]
+
-		f '[[]]
+solveGoal(Goal, Caller) ->
-		true (throw (Exception. "No applicable rule"))))
+    %% Fetch rules...
 	ApplicableRules = ets:match(rules,{Goal, '$1', '$2'}),
-(defn solve-goal [goal]
+	lists:foreach(
-	(let [rules (fetch-rules goal)]
+		fun([RuleBody,Truth]) ->
-		(if (some empty? rules)
+		if
-			1.0		; return a truth value
+			%% If RHS is null
-			(do
+			RuleBody == [] -> Caller ! {Goal, Truth};
-				(doseq [rule rules]
+			%% If RHS contains subgoals
-					(.submit completion-service #(solve-rule rule)))
+			true -> spawn(backward, solveRule, [RuleBody, self()])
-				(.get (.take completion-service))))))
+		end end,
 		ApplicableRules),
-; Move minimization logic here from collect.
+	receive
-(defn solve-rule [rule-tail]
+		%% Each message is of the form {goal,truth}
-	(let [truths (collect solve-goal rule-tail)]
+		%% Just accept the 1st answer
-		(apply + truths)))
+		{_, Truth} -> Caller ! {Goal, Truth}
 	end.
-; Accumulate results
+
-(def collect (if use-parallel-collect pmap map))
+solveRule(RuleTail, Caller) ->
 	N = length(RuleTail),
 	Collector = spawn(backward, collect, [[], N, Caller]),
 	%% For each subgoal in Rule
 	%% Spawn a process to solve each subgoal
 	lists:foreach(
 		fun(Subgoal) -> spawn(backward, solveGoal, [Subgoal, Collector]) end,
 		RuleTail).
 
 %% Accumulate results
 collect(Truths, N, Caller) ->
 	%% If we have N messages send back the answer
 	%% Answer = min of truth values, equivalent to fuzzy-logic AND
 	if length(Truths) == N -> Caller ! {dont_care, lists:min(Truths)};
 	   true -> true
 	end,
 	receive
 		{_, Truth} -> collect([Truth | Truths], N, Caller)
 	end.