backward chaining in Erlang

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

-module(backward).
-export([start/0,mainLoop/0,solveGoal/2,solveRule/2,collect/3]).

start() ->
    %% Initialize knowledge base;  Notice the goal g has 2 rules applicable to it
    ets:new(rules, [bag, named_table]),
    ets:insert(rules, {g,[d,e,f,h,i,j],1.0}),
    ets:insert(rules, {g,[a,b,c],1.1}),
    ets:insert(rules, {a,[],0.1}),
    ets:insert(rules, {b,[],0.2}),
    ets:insert(rules, {c,[],0.3}),
    ets:insert(rules, {d,[],0.4}),
    ets:insert(rules, {e,[],0.5}),
    ets:insert(rules, {f,[],0.6}),
    ets:insert(rules, {h,[],0.7}),
    ets:insert(rules, {i,[],0.8}),
    ets:insert(rules, {j,[],0.9}),
    mainLoop().

mainLoop() ->
    Query = io:read("Enter query: "),
    if
        Query == {ok, x} -> exit(normal);
        true -> true
    end,
    Root = spawn(backward, solveGoal, [element(2, Query), self()]),
    receive
        {_, Truth} -> io:format("Answer is: ~w~n", [Truth]),
                      exit(Root, ok)       % terminate the remaining processes
    end,
    mainLoop().

solveGoal(Goal, Caller) ->
    %% Fetch rules...
    ApplicableRules = ets:match(rules,{Goal, '$1', '$2'}),
    lists:foreach(
        fun([RuleBody,Truth]) ->
        if
            %% If rule's body is null, return the truth value
            RuleBody == [] -> Caller ! {Goal, Truth};
            %% If rule's body contains subgoals, solve them recursively
            true -> spawn_link(backward, solveRule, [RuleBody, self()])
        end end,
        ApplicableRules),
    receive
        %% Each message is of the form {subgoal,truth}
        %% Just accept the 1st answer
        {_, Truth} -> Caller ! {Goal, Truth}
    end.

solveRule(RuleTail, Caller) ->
    N = length(RuleTail),
    Collector = spawn_link(backward, collect, [[], N, Caller]),
    %% For each subgoal in Rule, spawn a process to solve each subgoal
    lists:foreach(
        fun(Subgoal) -> spawn_link(backward, solveGoal, [Subgoal, Collector]) end,
        RuleTail).

%% Accumulate results
collect(Truths, N, Caller) ->
    %% Collect N messages before sending back an answer
    %% Answer = min of truth values, equivalent to fuzzy-logic AND
    %% "min" is changed to "sum" to examine the code's behavior
    if length(Truths) == N -> Caller ! {dont_care, lists:sum(Truths)};
       true -> true
    end,
    receive
        {_, Truth} -> collect([Truth | Truths], N, Caller)
    end.