fork/join with parallel quicksort as example (Erlang)

fj.erl

-module(fj).

-export([parallel/2]).

%%%-----------------------------------------------------------------------------
%%% @doc Executes the given function on every task in tasks in parallel.
%%% @spec parallel(Function, Tasks) -> Results
%%%       where Results is a list matching the arity of input list Tasks
%%%       but contains the result of invoking Function on those tasks
%%% @end
%%%-----------------------------------------------------------------------------
parallel(Function, Tasks) ->
    Pids = fork(Function, Tasks),
    join(Pids).

%%------------------------------------------------------------------------------
%% @doc Forks all tasks in given list Tasks to new Erlang processes. Those
%%      processes invoke Function on forked tasks.
%% @spec fork(Function, Tasks) -> Pids
%%       where Pids is a list of process IDs
%% @end
%%------------------------------------------------------------------------------
fork(Function, Tasks) ->
    Parent = self(),
    Pids = lists:map(fun(Task) ->
                             spawn(fun() ->
                                           invoke(Parent, Function, Task)
                                   end)
                     end, Tasks),
    Pids.

join([P|Ps]) ->
    receive
        {P, Result} -> [Result|join(Ps)]
    end;
join([]) ->
    [].

invoke(Receiver, Function, Instance) ->
    Receiver ! {self(), (catch Function(Instance))}.

pqsort.erl

-module(pqsort).

-export([pqsort/1]).

pqsort([]) -> [];
pqsort([Pivot]) -> [Pivot];
pqsort([Pivot|Rest]) ->
    io:format("+", []),
    L = [X || X <- Rest, X < Pivot],
    R = [Y || Y <- Rest, Y >= Pivot],
    [SL, SR] = fj:parallel(fun pqsort/1, [L,R]),
    io:format("-", []),
    SL ++ [Pivot] ++ SR.