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

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.

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.