Erlang做流操作的方式是什么?

Question

假设我想这样做:

dict
  .values()
  .map(fun scrub/1)
  .flatMap(fun split/1)
  .groupBy(fun keyFun/1, fun count/1)
  .to_dict()

在Erlang中实现这一点的最优雅的方法是什么?

Answer 1

没有直接简单的方法可以做到这一点。我看到的所有尝试都比直接构图更糟糕。如果您查看Erlang中的大多数开源项目，就会发现它们使用泛型组合。重用您的示例:

to_dict(
groupBy(fun keyFun/1, fun count/1, 
flatMap(fun split/1, 
map(fun scrub/1, 
values(dict))))).

Answer 2

这不是Erlang中自然的结构。如果你有几个函数，我会使用常规组合:

lists:flatten(lists:map(fun (A) ->
                            do_stuff(A)
                        end,
                        generate_list())).

对于更长的操作序列，中间变量:

Dict = #{hello => world, ...},
Values = maps:values(Dict),
ScrubbedValues = lists:map(fun scrub/1, Values),
SplitValues = lists:flatten(lists:map(fun split/1, ScrubbedValues)),
GroupedValues = basil_lists:group_by(fun keyFun/1, fun count/1, SplitValues),
Dict2 = maps:from_list(GroupedValues).

如果你想把所有这些操作组合在一起，这就是它的样子。

然而，我更可能用另一种方式来写:

-spec remap_values(map()) -> map().
remap_values(Map) ->
    map_values(maps:values(Map)).
-spec map_values(list()) -> map().
map_values(Values) ->
    map_values(Values, [], []).
-spec map_values(list(), list(), list()) -> map().
map_values([], OutList, OutGroup) ->
    %% Base case: transform into a map
    Grouped = lists:zip(OutGroup, OutList),
    lists:foldl(fun ({Group, Element}, Acc = #{Group := Existing}) ->
                        Acc#{Group => [Element | Existing]};
                    ({Group, Element}, Acc) ->
                        Acc#{Group => [Element]}
                end,
                #{},
                Grouped;
map_values([First|Rest], OutList, OutGroup) ->
    %% Recursive case: categorize process the first element and categorize the result
    Processed = split(scrub(First)),
    Categories = lists:map(fun categorize/1, Processed),
    map_values(Rest, OutList ++ Processed, OutGroup ++ Categories).

实际正确的实现在很大程度上取决于代码的运行方式——我在这里写的代码非常简单，但在处理大量数据时可能表现不佳。如果你真的想处理无穷无尽的数据流，你需要自己写(尽管你可能会发现Gen Servers是一个非常有用的框架)。