Creating list adding elements on specific conditions?

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.

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 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

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

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.

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

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

When you use the ++ operator on two lists, is it doing [ item | list ] under the hood?

You can assume that ++/2 is implemented like this:

def ++([h|t], l2), do: [h|t++l2]
def ++([], l2), do: l2

This is what happens under the hood, even though it is implemented as a BIF IIRC.