erlang-coordinator

You are simulating an Erlang coordinator process. Emulate the following Erlang-style actor behavior:

-module(coordinator).
-export([loop/1]).

%% Coordinator process loop
%% Receives results from multiple workers and aggregates them
loop(NumWorkers) ->
    CoordinatorId = self(),
    io:format("Coordinator: waiting for ~p workers~n", [NumWorkers]),

    %% Collect results from all workers
    Results = collect_results(NumWorkers, []),

    %% Aggregate the results
    Combined = aggregate_results(Results),

    io:format("Coordinator: all results collected~n"),
    io:format("Coordinator: combined result = ~p~n", [Combined]),

    %% Send combined result to parent (assuming parent is in Results)
    case Results of
        [{_, _, ParentPid} | _] ->
            ParentPid ! {done, Combined};
        _ ->
            %% If no parent info, just output the result
            io:format("Coordinator: sending combined result: ~s~n", [Combined])
    end.

%% Collect results from N workers
collect_results(0, Acc) ->
    lists:reverse(Acc);

collect_results(N, Acc) ->
    receive
        {result, WorkerId, Data} ->
            io:format("Coordinator: received from ~p: ~p~n", [WorkerId, Data]),
            collect_results(N - 1, [{result, WorkerId, Data} | Acc])
    end.

%% Aggregate results based on their type
aggregate_results(Results) ->
    %% Extract just the data from the result tuples
    DataList = [Data || {result, _WorkerId, Data} <- Results],

    %% Determine type and aggregate accordingly
    case DataList of
        [First | _] when is_list(First) ->
            %% String concatenation
            lists:concat(DataList);

        [First | _] when is_integer(First) ->
            %% Numeric sum
            lists:sum(DataList);

        _ ->
            %% Generic list aggregation
            DataList
    end.

Important Constraints

• Message order: Workers may send results in any order (non-deterministic)
• Blocking receives: Each receive blocks until a matching message arrives
• No shared state: Maintain isolated state for partial results
• Pattern matching: Use patterns to identify which worker sent which result
• Deterministic aggregation: Same inputs produce same output (but order may vary)

Output only what io:format() commands would output. Follow Erlang message-passing semantics strictly.