我有一个列表,我想基于从结构类型B到a的转换进行块化。因此,例如,我有以下内容:
iex(1)> defmodule A, do: defstruct []
{:module, A ...
iex(2)> defmodule B, do: defstruct []
{:module, B ...
iex(3)> values = [ %A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{} ]
[%A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{}]
我想把这些数据分成一个2元素的列表,包含:
[ [ %A{}, %A{}, %B{}, %B{}, %B{} ], [ %A{}, %A{}, %B{} ] ]
如果初始输入全部为A或B,则输出将保持不变,因为没有发生B->A转换。
我认为Enum.chunk_by/2
是要走的路,但是我很难弄清楚如何维护前一个元素的上下文,以知道何时分裂。
这样的问题的惯用解决方案是什么样子的?
另一种方法是使用纯递归:
def collect_chunks([]), do: []
def collect_chunks(list) do
{chunk, post_chunk} = collect_chunk(list)
[chunk | collect_chunks(post_chunk)]
end
defp collect_chunk([]), do: {[], []}
defp collect_chunk([%B{} = last_element | [%A{} | _] = post_chunk]), do: {[last_element], post_chunk}
defp collect_chunk([el | rest]) do
{remaining_chunk, post_chunk} = collect_chunk(rest)
{[el | remaining_chunk], post_chunk}
end
另一种选择是chunk_by struct类型,然后再进行一次列表合并(除非列表包含%B{}
):
def chunk(structs) do
structs
|> Enum.chunk_by(& &1.__struct__)
|> merge()
end
# Don't merge when current is %B
defp merge([[%B{}|_]=h|t]), do: [h|merge(t)]
# Merge all others
defp merge([curr, next|t]), do: [curr ++ next|merge(t)]
# We are done
defp merge([]), do: []
Enum.chunk_by/2
目前不提供对前一个元素的访问,所以在这种情况下我们不能使用Enum.chunk_by/2
。我们将不得不退回到reduce/3
在所有Enum
函数中,reduce/3
是最灵活的,并且被大多数Enum
函数内部使用。
下面是生成所需输出的一种方法,给定值[ %A{}, %A{}, %B{}, %B{}, %B{}, %A{}, %A{}, %B{} ]
:
values
|> Enum.reduce([[]], fn (elem, acc) ->
prev_list = List.first(acc)
prev_elem = List.first(prev_list)
b_changed_to_a? = fn -> prev_elem.__struct__ == B && elem.__struct__ == A end
if is_nil(prev_elem) || !b_changed_to_a?.() do
List.replace_at(acc, 0, [elem|prev_list])
else
[[elem]|acc]
end
end)
|> Enum.map(&Enum.reverse/1)
|> Enum.reverse
注意,我总是在列表前添加一个元素。这是因为在Elixir中添加列表是一个昂贵的操作。
希望这个解决方案有帮助!