Creating list adding elements on specific conditions?

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!

1 Like

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.

1 Like

Thanks for the quick reply Ben!

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 :thumbsup: 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)

Something like this would work nicely :ok_hand:

My preferred approach would be:

[]
|> prepend_if_true(cond1, [1])
|> prepend_if_true(cond2, [2])
|> prepend_if_true(cond3, [3])
|> Enum.reverse()

defp prepend_if_true(list, cond, extra) do
  if cond, do: extra ++ list, else: list
end
6 Likes

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(map, _key, nil), do: map
  defp conditional_put(map, key, val), do: Map.put(map, key, val)

and for decimals:

  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

Those pipeline nicely.

3 Likes

Thank you @josevalim and @gregvaughn!

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.

Thanks everyone :beers:

3 Likes

Slightly different version of @josevalim his suggestion:

[]
|> append_if_true(cond1, 1)
|> append_if_true(cond2, 2)
|> append_if_true(cond3, 3)

defp append_if_true(list, true, item), do: list ++ [item]
defp append_if_true(list, _, _), do: list