Often I want to create a list in Elixir that contains certain elements, but only if specific conditions are met for each element or group of elements.
In a language with mutable data, it would be something like
array = [0]
if (cond1) {
array.push(1)
}
if (cond2) {
array.push(2)
}
if (cond3) {
array.push(3)
}
return array
How would you re-write this in Elixir?
Currently I’ve been creating separate lists for each condition and concatenating them in the end:
initial = [0]
list_1 = if cond1 do
[1]
else
[]
end
list_2 = if cond2 do
[2]
else
[]
end
list_3 = if cond3 do
[3]
else
[]
end
Enum.concat(initial, list_1)
|> Enum.concat(list_2)
|> Enum.concat(list_3)
This works but it’s not great, because I have to make sure I return an empty list every time. In some cases where logic in the if-block is complicated, it could lead to a lot of else [] end.
Any ideas how to refactor this to something more concise and/or avoid repetition are appreciated. Thanks!
There are some options, but some of them depend on what exactly cond1 is. By just having it as cond1 we’re just left with booleans, so the pattern matching isn’t as clean as it could be. Can you give some examples of conditions? A simple solution for your booleans is:
conditions =[
{cond1, 1},
{cond2, 2},
{cond3, 3},
]
list = Enum.reduce(conditions, [0], fn
{true, item}, list -> [item | list]
_, list -> list
end)
The idea is that we setup the conditions and the value associated with those conditions. Then we reduce those conditions into the list. If the condition is true, then we add the item. if it’s false, we don’t. If you need it to be appended instead of prepended you can just |> Enum.reverse afterward.
I’m indeed mostly dealing with booleans. I like the idea of reducing a set pre-defined conditions to produce the list, it didn’t occur to me at all Usually I need to do some work before I can produce the element to be added to the list (preload data, call other functions to calculate something, etc), so I’d probably modify your solution a little:
conditions =[
{cond1, :cond1},
{cond2, :cond2},
{cond3, :cond3}
]
list = Enum.reduce(conditions, [0], fn
{true, :cond1}, list ->
result = do_some_work()
[result | list]
{true, :cond2}, list ->
# ...
[result | list]
_, list -> list
end)
Just a couple of weeks ago we had something similar come up which involved collecting key/values into a map based upon conditions in another data structure. I came up with this helper function:
defp conditional_put_decimal(map, _key, nil), do: map
defp conditional_put_decimal(map, key, num_str) do
case Decimal.parse(num_str) do
{:ok, num} -> Map.put(map, key, num)
:error -> map
end
end
I took a bit of everyone’s suggestions and ended up with this helper function which I think strikes the best balance for me; I’m not manipulating large lists on this occasion, so I opted for appending rather than prepending for convenience:
def cond_append(list, false, _), do: list
def cond_append(list, true, fun) do
list ++ [fun.()]
end
def cond_append(list, bool_fun, value_fun) do
if bool_fun.(), do: list ++ [value_fun.()], else: list
end
I do have complex bool logic sometimes, hence the extra version accepting list, fun, fun.
Usually I need to do some work before I can produce the element to be added to the list (preload data, call other functions to calculate something, etc), so I’d probably modify your solution a little:
