Is there a more idiomatic way to fill the tail of a list with default values?
That is, given a list, return a list that is at least n
elements long, with a default value inserted if needed:
x = [1, 2, 3]
fill(x, 5, :default) # => [1, 2, 3, :default, :default]
This is what I came up with, you could also do it with zip, if the first arg was the correct length filled with default values, but that seems needlessly “allocate-y”. Also you could do some recursive function.
# This seems the most simple to understand, but could be expensive if the lists are big?
fill_concat = fn list, len, default ->
# Stream.repeatedly (or cycle) probably best if count is large enough
# to make [:default, :default ...] problematic if just writing this
# directly in another function.
list
|> Enum.concat(Stream.repeatedly(fn -> default end) |> Enum.take(len))
|> Enum.take(len)
end
fill_stream =
fn list, len, default ->
# *probably* faster, at least when the size is under the cost of creating a stream etc.
Stream.unfold({list, len}, fn
{_, 0} -> nil
{[x | xs], count} -> {x, {xs, count - 1}}
{[], count} -> {default, {[], count - 1}}
end)
|> Enum.to_list()
end
x = [1, 2]
fill_concat.(x, 5, :concat)
|> IO.inspect()
fill_stream.(x, 5, :stream)
|> IO.inspect()
Maybe this is the way to do it, but it feels a bit over done?